# ! [ doc = "Peripheral access API for ATSAM3X8E microcontrollers (generated using svd2rust v0.14.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.14.0/svd2rust/#peripheral-api" ] # ! [ deny ( missing_docs ) ] # ! [ deny ( warnings ) ] # ! [ allow ( non_camel_case_types ) ] # ! [ no_std ] # ! [ feature ( untagged_unions ) ] extern crate cortex_m ; # [ cfg ( feature = "rt" ) ] extern crate cortex_m_rt ; extern crate bare_metal ; extern crate vcell ; use core :: ops :: Deref ; use core :: marker :: PhantomData ; # [ doc = r" Number available in the NVIC for configuring priority" ] pub const NVIC_PRIO_BITS : u8 = 4 ; # [ cfg ( feature = "rt" ) ] extern "C" { fn PMC ( ) ; fn EFC0 ( ) ; fn EFC1 ( ) ; fn UART ( ) ; fn PIOA ( ) ; fn PIOB ( ) ; fn PIOC ( ) ; fn PIOD ( ) ; fn USART0 ( ) ; fn USART1 ( ) ; fn USART2 ( ) ; fn USART3 ( ) ; fn HSMCI ( ) ; fn TWI0 ( ) ; fn TWI1 ( ) ; fn SPI0 ( ) ; fn SSC ( ) ; fn TC0 ( ) ; fn TC1 ( ) ; fn TC2 ( ) ; fn TC3 ( ) ; fn TC4 ( ) ; fn TC5 ( ) ; fn TC6 ( ) ; fn TC7 ( ) ; fn TC8 ( ) ; fn PWM ( ) ; fn ADC ( ) ; fn DACC ( ) ; fn DMAC ( ) ; fn UOTGHS ( ) ; fn TRNG ( ) ; fn EMAC ( ) ; fn CAN0 ( ) ; fn CAN1 ( ) ; } # [ 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 ; 45 ] = [ Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _handler : PMC } , Vector { _handler : EFC0 } , Vector { _handler : EFC1 } , Vector { _handler : UART } , Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _handler : PIOA } , Vector { _handler : PIOB } , Vector { _handler : PIOC } , Vector { _handler : PIOD } , Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _handler : USART0 } , Vector { _handler : USART1 } , Vector { _handler : USART2 } , Vector { _handler : USART3 } , Vector { _handler : HSMCI } , Vector { _handler : TWI0 } , Vector { _handler : TWI1 } , Vector { _handler : SPI0 } , Vector { _reserved : 0 } , Vector { _handler : SSC } , Vector { _handler : TC0 } , Vector { _handler : TC1 } , Vector { _handler : TC2 } , Vector { _handler : TC3 } , Vector { _handler : TC4 } , Vector { _handler : TC5 } , Vector { _handler : TC6 } , Vector { _handler : TC7 } , Vector { _handler : TC8 } , Vector { _handler : PWM } , Vector { _handler : ADC } , Vector { _handler : DACC } , Vector { _handler : DMAC } , Vector { _handler : UOTGHS } , Vector { _handler : TRNG } , Vector { _handler : EMAC } , Vector { _handler : CAN0 } , Vector { _handler : CAN1 } , ] ; # [ doc = r" Enumeration of all the interrupts" ] # [ derive ( Copy , Clone , Debug ) ] pub enum Interrupt { # [ doc = "5 - PMC" ] PMC , # [ doc = "6 - EFC0" ] EFC0 , # [ doc = "7 - EFC1" ] EFC1 , # [ doc = "8 - UART" ] UART , # [ doc = "11 - PIOA" ] PIOA , # [ doc = "12 - PIOB" ] PIOB , # [ doc = "13 - PIOC" ] PIOC , # [ doc = "14 - PIOD" ] PIOD , # [ doc = "17 - USART0" ] USART0 , # [ doc = "18 - USART1" ] USART1 , # [ doc = "19 - USART2" ] USART2 , # [ doc = "20 - USART3" ] USART3 , # [ doc = "21 - HSMCI" ] HSMCI , # [ doc = "22 - TWI0" ] TWI0 , # [ doc = "23 - TWI1" ] TWI1 , # [ doc = "24 - SPI0" ] SPI0 , # [ doc = "26 - SSC" ] SSC , # [ doc = "27 - TC0" ] TC0 , # [ doc = "28 - TC1" ] TC1 , # [ doc = "29 - TC2" ] TC2 , # [ doc = "30 - TC3" ] TC3 , # [ doc = "31 - TC4" ] TC4 , # [ doc = "32 - TC5" ] TC5 , # [ doc = "33 - TC6" ] TC6 , # [ doc = "34 - TC7" ] TC7 , # [ doc = "35 - TC8" ] TC8 , # [ doc = "36 - PWM" ] PWM , # [ doc = "37 - ADC" ] ADC , # [ doc = "38 - DACC" ] DACC , # [ doc = "39 - DMAC" ] DMAC , # [ doc = "40 - UOTGHS" ] UOTGHS , # [ doc = "41 - TRNG" ] TRNG , # [ doc = "42 - EMAC" ] EMAC , # [ doc = "43 - CAN0" ] CAN0 , # [ doc = "44 - CAN1" ] CAN1 , } unsafe impl :: bare_metal :: Nr for Interrupt { # [ inline ] fn nr ( & self ) -> u8 { match * self { Interrupt :: PMC => 5 , Interrupt :: EFC0 => 6 , Interrupt :: EFC1 => 7 , Interrupt :: UART => 8 , Interrupt :: PIOA => 11 , Interrupt :: PIOB => 12 , Interrupt :: PIOC => 13 , Interrupt :: PIOD => 14 , Interrupt :: USART0 => 17 , Interrupt :: USART1 => 18 , Interrupt :: USART2 => 19 , Interrupt :: USART3 => 20 , Interrupt :: HSMCI => 21 , Interrupt :: TWI0 => 22 , Interrupt :: TWI1 => 23 , Interrupt :: SPI0 => 24 , Interrupt :: SSC => 26 , Interrupt :: TC0 => 27 , Interrupt :: TC1 => 28 , Interrupt :: TC2 => 29 , Interrupt :: TC3 => 30 , Interrupt :: TC4 => 31 , Interrupt :: TC5 => 32 , Interrupt :: TC6 => 33 , Interrupt :: TC7 => 34 , Interrupt :: TC8 => 35 , Interrupt :: PWM => 36 , Interrupt :: ADC => 37 , Interrupt :: DACC => 38 , Interrupt :: DMAC => 39 , Interrupt :: UOTGHS => 40 , Interrupt :: TRNG => 41 , Interrupt :: EMAC => 42 , Interrupt :: CAN0 => 43 , Interrupt :: CAN1 => 44 , } } } pub use cortex_m :: peripheral :: Peripherals as CorePeripherals ; # [ cfg ( feature = "rt" ) ] pub use cortex_m_rt :: interrupt ; # [ cfg ( feature = "rt" ) ] pub use self :: Interrupt as interrupt ; pub use cortex_m :: peripheral :: { CBP , CPUID , DCB , DWT , FPB , ITM , MPU , NVIC , SCB , SYST , TPIU , } ; # [ doc = "High Speed MultiMedia Card Interface" ] pub struct HSMCI { _marker : PhantomData < * const ( ) > } unsafe impl Send for HSMCI { } impl HSMCI { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const hsmci :: RegisterBlock { 0x4000_0000 as * const _ } } impl Deref for HSMCI { type Target = hsmci :: RegisterBlock ; fn deref ( & self ) -> & hsmci :: RegisterBlock { unsafe { & * HSMCI :: ptr ( ) } } } # [ doc = "High Speed MultiMedia Card Interface" ] pub mod hsmci { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Mode Register" ] pub mr : MR , # [ doc = "0x08 - Data Timeout Register" ] pub dtor : DTOR , # [ doc = "0x0c - SD/SDIO Card Register" ] pub sdcr : SDCR , # [ doc = "0x10 - Argument Register" ] pub argr : ARGR , # [ doc = "0x14 - Command Register" ] pub cmdr : CMDR , # [ doc = "0x18 - Block Register" ] pub blkr : BLKR , # [ doc = "0x1c - Completion Signal Timeout Register" ] pub cstor : CSTOR , # [ doc = "0x20 - Response Register" ] pub rspr : [ RSPR ; 4 ] , # [ doc = "0x30 - Receive Data Register" ] pub rdr : RDR , # [ doc = "0x34 - Transmit Data Register" ] pub tdr : TDR , _reserved11 : [ u8 ; 8usize ] , # [ doc = "0x40 - Status Register" ] pub sr : SR , # [ doc = "0x44 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x48 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x4c - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x50 - DMA Configuration Register" ] pub dma : DMA , # [ doc = "0x54 - Configuration Register" ] pub cfg : CFG , _reserved17 : [ u8 ; 140usize ] , # [ doc = "0xe4 - Write Protection Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protection Status Register" ] pub wpsr : WPSR , _reserved19 : [ u8 ; 276usize ] , # [ doc = "0x200 - FIFO Memory Aperture0" ] pub fifo : [ FIFO ; 256 ] , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MCIENW < 'a > { w : & 'a mut W , } impl < 'a > _MCIENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MCIDISW < 'a > { w : & 'a mut W , } impl < 'a > _MCIDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PWSENW < 'a > { w : & 'a mut W , } impl < 'a > _PWSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PWSDISW < 'a > { w : & 'a mut W , } impl < 'a > _PWSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 7 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bit 0 - Multi-Media Interface Enable" ] # [ inline ] pub fn mcien ( & mut self ) -> _MCIENW { _MCIENW { w : self } } # [ doc = "Bit 1 - Multi-Media Interface Disable" ] # [ inline ] pub fn mcidis ( & mut self ) -> _MCIDISW { _MCIDISW { w : self } } # [ doc = "Bit 2 - Power Save Mode Enable" ] # [ inline ] pub fn pwsen ( & mut self ) -> _PWSENW { _PWSENW { w : self } } # [ doc = "Bit 3 - Power Save Mode Disable" ] # [ inline ] pub fn pwsdis ( & mut self ) -> _PWSDISW { _PWSDISW { w : self } } # [ doc = "Bit 7 - Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CLKDIVR { bits : u8 , } impl CLKDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PWSDIVR { bits : u8 , } impl PWSDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RDPROOFR { bits : bool , } impl RDPROOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WRPROOFR { bits : bool , } impl WRPROOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FBYTER { bits : bool , } impl FBYTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PADVR { bits : bool , } impl PADVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CLKDIVW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDIVW < '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 _PWSDIVW < 'a > { w : & 'a mut W , } impl < 'a > _PWSDIVW < '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 _RDPROOFW < 'a > { w : & 'a mut W , } impl < 'a > _RDPROOFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WRPROOFW < 'a > { w : & 'a mut W , } impl < 'a > _WRPROOFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FBYTEW < 'a > { w : & 'a mut W , } impl < 'a > _FBYTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PADVW < 'a > { w : & 'a mut W , } impl < 'a > _PADVW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:7 - Clock Divider" ] # [ inline ] pub fn clkdiv ( & self ) -> CLKDIVR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CLKDIVR { bits } } # [ doc = "Bits 8:10 - Power Saving Divider" ] # [ inline ] pub fn pwsdiv ( & self ) -> PWSDIVR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PWSDIVR { bits } } # [ doc = "Bit 11 - Read Proof Enable" ] # [ inline ] pub fn rdproof ( & self ) -> RDPROOFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RDPROOFR { bits } } # [ doc = "Bit 12 - Write Proof Enable" ] # [ inline ] pub fn wrproof ( & self ) -> WRPROOFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WRPROOFR { bits } } # [ doc = "Bit 13 - Force Byte Transfer" ] # [ inline ] pub fn fbyte ( & self ) -> FBYTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FBYTER { bits } } # [ doc = "Bit 14 - Padding Value" ] # [ inline ] pub fn padv ( & self ) -> PADVR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PADVR { 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 - Clock Divider" ] # [ inline ] pub fn clkdiv ( & mut self ) -> _CLKDIVW { _CLKDIVW { w : self } } # [ doc = "Bits 8:10 - Power Saving Divider" ] # [ inline ] pub fn pwsdiv ( & mut self ) -> _PWSDIVW { _PWSDIVW { w : self } } # [ doc = "Bit 11 - Read Proof Enable" ] # [ inline ] pub fn rdproof ( & mut self ) -> _RDPROOFW { _RDPROOFW { w : self } } # [ doc = "Bit 12 - Write Proof Enable" ] # [ inline ] pub fn wrproof ( & mut self ) -> _WRPROOFW { _WRPROOFW { w : self } } # [ doc = "Bit 13 - Force Byte Transfer" ] # [ inline ] pub fn fbyte ( & mut self ) -> _FBYTEW { _FBYTEW { w : self } } # [ doc = "Bit 14 - Padding Value" ] # [ inline ] pub fn padv ( & mut self ) -> _PADVW { _PADVW { w : self } } } } # [ doc = "Data Timeout Register" ] pub struct DTOR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Data Timeout Register" ] pub mod dtor { # [ 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 :: DTOR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTOCYCR { bits : u8 , } impl DTOCYCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `DTOMUL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DTOMULR { # [ doc = "DTOCYC" ] _1 , # [ doc = "DTOCYC x 16" ] _16 , # [ doc = "DTOCYC x 128" ] _128 , # [ doc = "DTOCYC x 256" ] _256 , # [ doc = "DTOCYC x 1024" ] _1024 , # [ doc = "DTOCYC x 4096" ] _4096 , # [ doc = "DTOCYC x 65536" ] _65536 , # [ doc = "DTOCYC x 1048576" ] _1048576 } impl DTOMULR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DTOMULR :: _1 => 0 , DTOMULR :: _16 => 0x01 , DTOMULR :: _128 => 0x02 , DTOMULR :: _256 => 0x03 , DTOMULR :: _1024 => 0x04 , DTOMULR :: _4096 => 0x05 , DTOMULR :: _65536 => 0x06 , DTOMULR :: _1048576 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DTOMULR { match value { 0 => DTOMULR :: _1 , 1 => DTOMULR :: _16 , 2 => DTOMULR :: _128 , 3 => DTOMULR :: _256 , 4 => DTOMULR :: _1024 , 5 => DTOMULR :: _4096 , 6 => DTOMULR :: _65536 , 7 => DTOMULR :: _1048576 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_1`" ] # [ inline ] pub fn is_1 ( & self ) -> bool { * self == DTOMULR :: _1 } # [ doc = "Checks if the value of the field is `_16`" ] # [ inline ] pub fn is_16 ( & self ) -> bool { * self == DTOMULR :: _16 } # [ doc = "Checks if the value of the field is `_128`" ] # [ inline ] pub fn is_128 ( & self ) -> bool { * self == DTOMULR :: _128 } # [ doc = "Checks if the value of the field is `_256`" ] # [ inline ] pub fn is_256 ( & self ) -> bool { * self == DTOMULR :: _256 } # [ doc = "Checks if the value of the field is `_1024`" ] # [ inline ] pub fn is_1024 ( & self ) -> bool { * self == DTOMULR :: _1024 } # [ doc = "Checks if the value of the field is `_4096`" ] # [ inline ] pub fn is_4096 ( & self ) -> bool { * self == DTOMULR :: _4096 } # [ doc = "Checks if the value of the field is `_65536`" ] # [ inline ] pub fn is_65536 ( & self ) -> bool { * self == DTOMULR :: _65536 } # [ doc = "Checks if the value of the field is `_1048576`" ] # [ inline ] pub fn is_1048576 ( & self ) -> bool { * self == DTOMULR :: _1048576 } } # [ doc = r" Proxy" ] pub struct _DTOCYCW < 'a > { w : & 'a mut W , } impl < 'a > _DTOCYCW < '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 } } # [ doc = "Values that can be written to the field `DTOMUL`" ] pub enum DTOMULW { # [ doc = "DTOCYC" ] _1 , # [ doc = "DTOCYC x 16" ] _16 , # [ doc = "DTOCYC x 128" ] _128 , # [ doc = "DTOCYC x 256" ] _256 , # [ doc = "DTOCYC x 1024" ] _1024 , # [ doc = "DTOCYC x 4096" ] _4096 , # [ doc = "DTOCYC x 65536" ] _65536 , # [ doc = "DTOCYC x 1048576" ] _1048576 } impl DTOMULW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DTOMULW :: _1 => 0 , DTOMULW :: _16 => 1 , DTOMULW :: _128 => 2 , DTOMULW :: _256 => 3 , DTOMULW :: _1024 => 4 , DTOMULW :: _4096 => 5 , DTOMULW :: _65536 => 6 , DTOMULW :: _1048576 => 7 } } } # [ doc = r" Proxy" ] pub struct _DTOMULW < 'a > { w : & 'a mut W , } impl < 'a > _DTOMULW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DTOMULW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "DTOCYC" ] # [ inline ] pub fn _1 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _1 ) } # [ doc = "DTOCYC x 16" ] # [ inline ] pub fn _16 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _16 ) } # [ doc = "DTOCYC x 128" ] # [ inline ] pub fn _128 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _128 ) } # [ doc = "DTOCYC x 256" ] # [ inline ] pub fn _256 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _256 ) } # [ doc = "DTOCYC x 1024" ] # [ inline ] pub fn _1024 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _1024 ) } # [ doc = "DTOCYC x 4096" ] # [ inline ] pub fn _4096 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _4096 ) } # [ doc = "DTOCYC x 65536" ] # [ inline ] pub fn _65536 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _65536 ) } # [ doc = "DTOCYC x 1048576" ] # [ inline ] pub fn _1048576 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: _1048576 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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:3 - Data Timeout Cycle Number" ] # [ inline ] pub fn dtocyc ( & self ) -> DTOCYCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DTOCYCR { bits } } # [ doc = "Bits 4:6 - Data Timeout Multiplier" ] # [ inline ] pub fn dtomul ( & self ) -> DTOMULR { DTOMULR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Data Timeout Cycle Number" ] # [ inline ] pub fn dtocyc ( & mut self ) -> _DTOCYCW { _DTOCYCW { w : self } } # [ doc = "Bits 4:6 - Data Timeout Multiplier" ] # [ inline ] pub fn dtomul ( & mut self ) -> _DTOMULW { _DTOMULW { w : self } } } } # [ doc = "SD/SDIO Card Register" ] pub struct SDCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SD/SDIO Card Register" ] pub mod sdcr { # [ 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 :: SDCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `SDCSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SDCSELR { # [ doc = "Slot A is selected." ] SLOTA , # [ doc = "SDCARD/SDIO Slot B selected" ] SLOTB , # [ doc = "-" ] SLOTC , # [ doc = "-" ] SLOTD } impl SDCSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SDCSELR :: SLOTA => 0 , SDCSELR :: SLOTB => 0x01 , SDCSELR :: SLOTC => 0x02 , SDCSELR :: SLOTD => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SDCSELR { match value { 0 => SDCSELR :: SLOTA , 1 => SDCSELR :: SLOTB , 2 => SDCSELR :: SLOTC , 3 => SDCSELR :: SLOTD , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `SLOTA`" ] # [ inline ] pub fn is_slota ( & self ) -> bool { * self == SDCSELR :: SLOTA } # [ doc = "Checks if the value of the field is `SLOTB`" ] # [ inline ] pub fn is_slotb ( & self ) -> bool { * self == SDCSELR :: SLOTB } # [ doc = "Checks if the value of the field is `SLOTC`" ] # [ inline ] pub fn is_slotc ( & self ) -> bool { * self == SDCSELR :: SLOTC } # [ doc = "Checks if the value of the field is `SLOTD`" ] # [ inline ] pub fn is_slotd ( & self ) -> bool { * self == SDCSELR :: SLOTD } } # [ doc = "Possible values of the field `SDCBUS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SDCBUSR { # [ doc = "1 bit" ] _1 , # [ doc = "4 bits" ] _4 , # [ doc = "8 bits" ] _8 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SDCBUSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SDCBUSR :: _1 => 0 , SDCBUSR :: _4 => 0x02 , SDCBUSR :: _8 => 0x03 , SDCBUSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SDCBUSR { match value { 0 => SDCBUSR :: _1 , 2 => SDCBUSR :: _4 , 3 => SDCBUSR :: _8 , i => SDCBUSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1`" ] # [ inline ] pub fn is_1 ( & self ) -> bool { * self == SDCBUSR :: _1 } # [ doc = "Checks if the value of the field is `_4`" ] # [ inline ] pub fn is_4 ( & self ) -> bool { * self == SDCBUSR :: _4 } # [ doc = "Checks if the value of the field is `_8`" ] # [ inline ] pub fn is_8 ( & self ) -> bool { * self == SDCBUSR :: _8 } } # [ doc = "Values that can be written to the field `SDCSEL`" ] pub enum SDCSELW { # [ doc = "Slot A is selected." ] SLOTA , # [ doc = "SDCARD/SDIO Slot B selected" ] SLOTB , # [ doc = "-" ] SLOTC , # [ doc = "-" ] SLOTD } impl SDCSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SDCSELW :: SLOTA => 0 , SDCSELW :: SLOTB => 1 , SDCSELW :: SLOTC => 2 , SDCSELW :: SLOTD => 3 } } } # [ doc = r" Proxy" ] pub struct _SDCSELW < 'a > { w : & 'a mut W , } impl < 'a > _SDCSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SDCSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Slot A is selected." ] # [ inline ] pub fn slota ( self ) -> & 'a mut W { self . variant ( SDCSELW :: SLOTA ) } # [ doc = "SDCARD/SDIO Slot B selected" ] # [ inline ] pub fn slotb ( self ) -> & 'a mut W { self . variant ( SDCSELW :: SLOTB ) } # [ doc = "-" ] # [ inline ] pub fn slotc ( self ) -> & 'a mut W { self . variant ( SDCSELW :: SLOTC ) } # [ doc = "-" ] # [ inline ] pub fn slotd ( self ) -> & 'a mut W { self . variant ( SDCSELW :: SLOTD ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SDCBUS`" ] pub enum SDCBUSW { # [ doc = "1 bit" ] _1 , # [ doc = "4 bits" ] _4 , # [ doc = "8 bits" ] _8 } impl SDCBUSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SDCBUSW :: _1 => 0 , SDCBUSW :: _4 => 2 , SDCBUSW :: _8 => 3 } } } # [ doc = r" Proxy" ] pub struct _SDCBUSW < 'a > { w : & 'a mut W , } impl < 'a > _SDCBUSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SDCBUSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 bit" ] # [ inline ] pub fn _1 ( self ) -> & 'a mut W { self . variant ( SDCBUSW :: _1 ) } # [ doc = "4 bits" ] # [ inline ] pub fn _4 ( self ) -> & 'a mut W { self . variant ( SDCBUSW :: _4 ) } # [ doc = "8 bits" ] # [ inline ] pub fn _8 ( self ) -> & 'a mut W { self . variant ( SDCBUSW :: _8 ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - SDCard/SDIO Slot" ] # [ inline ] pub fn sdcsel ( & self ) -> SDCSELR { SDCSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - SDCard/SDIO Bus Width" ] # [ inline ] pub fn sdcbus ( & self ) -> SDCBUSR { SDCBUSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - SDCard/SDIO Slot" ] # [ inline ] pub fn sdcsel ( & mut self ) -> _SDCSELW { _SDCSELW { w : self } } # [ doc = "Bits 6:7 - SDCard/SDIO Bus Width" ] # [ inline ] pub fn sdcbus ( & mut self ) -> _SDCBUSW { _SDCBUSW { w : self } } } } # [ doc = "Argument Register" ] pub struct ARGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Argument Register" ] pub mod argr { # [ 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 :: ARGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ARGR { bits : u32 , } impl ARGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ARGW < 'a > { w : & 'a mut W , } impl < 'a > _ARGW < '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 - Command Argument" ] # [ inline ] pub fn arg ( & self ) -> ARGR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ARGR { 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 - Command Argument" ] # [ inline ] pub fn arg ( & mut self ) -> _ARGW { _ARGW { w : self } } } } # [ doc = "Command Register" ] pub struct CMDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Command Register" ] pub mod cmdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CMDNBW < 'a > { w : & 'a mut W , } impl < 'a > _CMDNBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `RSPTYP`" ] pub enum RSPTYPW { # [ doc = "No response" ] NORESP , # [ doc = "48-bit response" ] _48_BIT , # [ doc = "136-bit response" ] _136_BIT , # [ doc = "R1b response type" ] R1B } impl RSPTYPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RSPTYPW :: NORESP => 0 , RSPTYPW :: _48_BIT => 1 , RSPTYPW :: _136_BIT => 2 , RSPTYPW :: R1B => 3 } } } # [ doc = r" Proxy" ] pub struct _RSPTYPW < 'a > { w : & 'a mut W , } impl < 'a > _RSPTYPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RSPTYPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "No response" ] # [ inline ] pub fn noresp ( self ) -> & 'a mut W { self . variant ( RSPTYPW :: NORESP ) } # [ doc = "48-bit response" ] # [ inline ] pub fn _48_bit ( self ) -> & 'a mut W { self . variant ( RSPTYPW :: _48_BIT ) } # [ doc = "136-bit response" ] # [ inline ] pub fn _136_bit ( self ) -> & 'a mut W { self . variant ( RSPTYPW :: _136_BIT ) } # [ doc = "R1b response type" ] # [ inline ] pub fn r1b ( self ) -> & 'a mut W { self . variant ( RSPTYPW :: R1B ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SPCMD`" ] pub enum SPCMDW { # [ doc = "Not a special CMD." ] STD , # [ doc = "Initialization CMD: 74 clock cycles for initialization sequence." ] INIT , # [ doc = "Synchronized CMD: Wait for the end of the current data block transfer before sending the pending command." ] SYNC , # [ doc = "CE-ATA Completion Signal disable Command. The host cancels the ability for the device to return a command completion signal on the command line." ] CE_ATA , # [ doc = "Interrupt command: Corresponds to the Interrupt Mode (CMD40)." ] IT_CMD , # [ doc = "Interrupt response: Corresponds to the Interrupt Mode (CMD40)." ] IT_RESP , # [ doc = "Boot Operation Request. Start a boot operation mode, the host processor can read boot data from the MMC device directly." ] BOR , # [ doc = "End Boot Operation. This command allows the host processor to terminate the boot operation mode." ] EBO } impl SPCMDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SPCMDW :: STD => 0 , SPCMDW :: INIT => 1 , SPCMDW :: SYNC => 2 , SPCMDW :: CE_ATA => 3 , SPCMDW :: IT_CMD => 4 , SPCMDW :: IT_RESP => 5 , SPCMDW :: BOR => 6 , SPCMDW :: EBO => 7 } } } # [ doc = r" Proxy" ] pub struct _SPCMDW < 'a > { w : & 'a mut W , } impl < 'a > _SPCMDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SPCMDW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Not a special CMD." ] # [ inline ] pub fn std ( self ) -> & 'a mut W { self . variant ( SPCMDW :: STD ) } # [ doc = "Initialization CMD: 74 clock cycles for initialization sequence." ] # [ inline ] pub fn init ( self ) -> & 'a mut W { self . variant ( SPCMDW :: INIT ) } # [ doc = "Synchronized CMD: Wait for the end of the current data block transfer before sending the pending command." ] # [ inline ] pub fn sync ( self ) -> & 'a mut W { self . variant ( SPCMDW :: SYNC ) } # [ doc = "CE-ATA Completion Signal disable Command. The host cancels the ability for the device to return a command completion signal on the command line." ] # [ inline ] pub fn ce_ata ( self ) -> & 'a mut W { self . variant ( SPCMDW :: CE_ATA ) } # [ doc = "Interrupt command: Corresponds to the Interrupt Mode (CMD40)." ] # [ inline ] pub fn it_cmd ( self ) -> & 'a mut W { self . variant ( SPCMDW :: IT_CMD ) } # [ doc = "Interrupt response: Corresponds to the Interrupt Mode (CMD40)." ] # [ inline ] pub fn it_resp ( self ) -> & 'a mut W { self . variant ( SPCMDW :: IT_RESP ) } # [ doc = "Boot Operation Request. Start a boot operation mode, the host processor can read boot data from the MMC device directly." ] # [ inline ] pub fn bor ( self ) -> & 'a mut W { self . variant ( SPCMDW :: BOR ) } # [ doc = "End Boot Operation. This command allows the host processor to terminate the boot operation mode." ] # [ inline ] pub fn ebo ( self ) -> & 'a mut W { self . variant ( SPCMDW :: EBO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `OPDCMD`" ] pub enum OPDCMDW { # [ doc = "Push pull command." ] PUSHPULL , # [ doc = "Open drain command." ] OPENDRAIN } impl OPDCMDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { OPDCMDW :: PUSHPULL => false , OPDCMDW :: OPENDRAIN => true } } } # [ doc = r" Proxy" ] pub struct _OPDCMDW < 'a > { w : & 'a mut W , } impl < 'a > _OPDCMDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : OPDCMDW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Push pull command." ] # [ inline ] pub fn pushpull ( self ) -> & 'a mut W { self . variant ( OPDCMDW :: PUSHPULL ) } # [ doc = "Open drain command." ] # [ inline ] pub fn opendrain ( self ) -> & 'a mut W { self . variant ( OPDCMDW :: OPENDRAIN ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `MAXLAT`" ] pub enum MAXLATW { # [ doc = "5-cycle max latency." ] _5 , # [ doc = "64-cycle max latency." ] _64 } impl MAXLATW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { MAXLATW :: _5 => false , MAXLATW :: _64 => true } } } # [ doc = r" Proxy" ] pub struct _MAXLATW < 'a > { w : & 'a mut W , } impl < 'a > _MAXLATW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MAXLATW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "5-cycle max latency." ] # [ inline ] pub fn _5 ( self ) -> & 'a mut W { self . variant ( MAXLATW :: _5 ) } # [ doc = "64-cycle max latency." ] # [ inline ] pub fn _64 ( self ) -> & 'a mut W { self . variant ( MAXLATW :: _64 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `TRCMD`" ] pub enum TRCMDW { # [ doc = "No data transfer" ] NO_DATA , # [ doc = "Start data transfer" ] START_DATA , # [ doc = "Stop data transfer" ] STOP_DATA } impl TRCMDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TRCMDW :: NO_DATA => 0 , TRCMDW :: START_DATA => 1 , TRCMDW :: STOP_DATA => 2 } } } # [ doc = r" Proxy" ] pub struct _TRCMDW < 'a > { w : & 'a mut W , } impl < 'a > _TRCMDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TRCMDW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "No data transfer" ] # [ inline ] pub fn no_data ( self ) -> & 'a mut W { self . variant ( TRCMDW :: NO_DATA ) } # [ doc = "Start data transfer" ] # [ inline ] pub fn start_data ( self ) -> & 'a mut W { self . variant ( TRCMDW :: START_DATA ) } # [ doc = "Stop data transfer" ] # [ inline ] pub fn stop_data ( self ) -> & 'a mut W { self . variant ( TRCMDW :: STOP_DATA ) } # [ 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 = "Values that can be written to the field `TRDIR`" ] pub enum TRDIRW { # [ doc = "Write." ] WRITE , # [ doc = "Read." ] READ } impl TRDIRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { TRDIRW :: WRITE => false , TRDIRW :: READ => true } } } # [ doc = r" Proxy" ] pub struct _TRDIRW < 'a > { w : & 'a mut W , } impl < 'a > _TRDIRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TRDIRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Write." ] # [ inline ] pub fn write ( self ) -> & 'a mut W { self . variant ( TRDIRW :: WRITE ) } # [ doc = "Read." ] # [ inline ] pub fn read ( self ) -> & 'a mut W { self . variant ( TRDIRW :: READ ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `TRTYP`" ] pub enum TRTYPW { # [ doc = "MMC/SD Card Single Block" ] SINGLE , # [ doc = "MMC/SD Card Multiple Block" ] MULTIPLE , # [ doc = "MMC Stream" ] STREAM , # [ doc = "SDIO Byte" ] BYTE , # [ doc = "SDIO Block" ] BLOCK } impl TRTYPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TRTYPW :: SINGLE => 0 , TRTYPW :: MULTIPLE => 1 , TRTYPW :: STREAM => 2 , TRTYPW :: BYTE => 4 , TRTYPW :: BLOCK => 5 } } } # [ doc = r" Proxy" ] pub struct _TRTYPW < 'a > { w : & 'a mut W , } impl < 'a > _TRTYPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TRTYPW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "MMC/SD Card Single Block" ] # [ inline ] pub fn single ( self ) -> & 'a mut W { self . variant ( TRTYPW :: SINGLE ) } # [ doc = "MMC/SD Card Multiple Block" ] # [ inline ] pub fn multiple ( self ) -> & 'a mut W { self . variant ( TRTYPW :: MULTIPLE ) } # [ doc = "MMC Stream" ] # [ inline ] pub fn stream ( self ) -> & 'a mut W { self . variant ( TRTYPW :: STREAM ) } # [ doc = "SDIO Byte" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( TRTYPW :: BYTE ) } # [ doc = "SDIO Block" ] # [ inline ] pub fn block ( self ) -> & 'a mut W { self . variant ( TRTYPW :: BLOCK ) } # [ 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 = 19 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `IOSPCMD`" ] pub enum IOSPCMDW { # [ doc = "Not an SDIO Special Command" ] STD , # [ doc = "SDIO Suspend Command" ] SUSPEND , # [ doc = "SDIO Resume Command" ] RESUME } impl IOSPCMDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { IOSPCMDW :: STD => 0 , IOSPCMDW :: SUSPEND => 1 , IOSPCMDW :: RESUME => 2 } } } # [ doc = r" Proxy" ] pub struct _IOSPCMDW < 'a > { w : & 'a mut W , } impl < 'a > _IOSPCMDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : IOSPCMDW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Not an SDIO Special Command" ] # [ inline ] pub fn std ( self ) -> & 'a mut W { self . variant ( IOSPCMDW :: STD ) } # [ doc = "SDIO Suspend Command" ] # [ inline ] pub fn suspend ( self ) -> & 'a mut W { self . variant ( IOSPCMDW :: SUSPEND ) } # [ doc = "SDIO Resume Command" ] # [ inline ] pub fn resume ( self ) -> & 'a mut W { self . variant ( IOSPCMDW :: RESUME ) } # [ 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 = "Values that can be written to the field `ATACS`" ] pub enum ATACSW { # [ doc = "Normal operation mode." ] NORMAL , # [ doc = "This bit indicates that a completion signal is expected within a programmed amount of time (HSMCI_CSTOR)." ] COMPLETION } impl ATACSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { ATACSW :: NORMAL => false , ATACSW :: COMPLETION => true } } } # [ doc = r" Proxy" ] pub struct _ATACSW < 'a > { w : & 'a mut W , } impl < 'a > _ATACSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ATACSW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Normal operation mode." ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( ATACSW :: NORMAL ) } # [ doc = "This bit indicates that a completion signal is expected within a programmed amount of time (HSMCI_CSTOR)." ] # [ inline ] pub fn completion ( self ) -> & 'a mut W { self . variant ( ATACSW :: COMPLETION ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BOOT_ACKW < 'a > { w : & 'a mut W , } impl < 'a > _BOOT_ACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:5 - Command Number" ] # [ inline ] pub fn cmdnb ( & mut self ) -> _CMDNBW { _CMDNBW { w : self } } # [ doc = "Bits 6:7 - Response Type" ] # [ inline ] pub fn rsptyp ( & mut self ) -> _RSPTYPW { _RSPTYPW { w : self } } # [ doc = "Bits 8:10 - Special Command" ] # [ inline ] pub fn spcmd ( & mut self ) -> _SPCMDW { _SPCMDW { w : self } } # [ doc = "Bit 11 - Open Drain Command" ] # [ inline ] pub fn opdcmd ( & mut self ) -> _OPDCMDW { _OPDCMDW { w : self } } # [ doc = "Bit 12 - Max Latency for Command to Response" ] # [ inline ] pub fn maxlat ( & mut self ) -> _MAXLATW { _MAXLATW { w : self } } # [ doc = "Bits 16:17 - Transfer Command" ] # [ inline ] pub fn trcmd ( & mut self ) -> _TRCMDW { _TRCMDW { w : self } } # [ doc = "Bit 18 - Transfer Direction" ] # [ inline ] pub fn trdir ( & mut self ) -> _TRDIRW { _TRDIRW { w : self } } # [ doc = "Bits 19:21 - Transfer Type" ] # [ inline ] pub fn trtyp ( & mut self ) -> _TRTYPW { _TRTYPW { w : self } } # [ doc = "Bits 24:25 - SDIO Special Command" ] # [ inline ] pub fn iospcmd ( & mut self ) -> _IOSPCMDW { _IOSPCMDW { w : self } } # [ doc = "Bit 26 - ATA with Command Completion Signal" ] # [ inline ] pub fn atacs ( & mut self ) -> _ATACSW { _ATACSW { w : self } } # [ doc = "Bit 27 - Boot Operation Acknowledge" ] # [ inline ] pub fn boot_ack ( & mut self ) -> _BOOT_ACKW { _BOOT_ACKW { w : self } } } } # [ doc = "Block Register" ] pub struct BLKR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Block Register" ] pub mod blkr { # [ 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 :: BLKR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BCNTR { bits : u16 , } impl BCNTR { # [ 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 BLKLENR { bits : u16 , } impl BLKLENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _BCNTW < 'a > { w : & 'a mut W , } impl < 'a > _BCNTW < '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 } } # [ doc = r" Proxy" ] pub struct _BLKLENW < 'a > { w : & 'a mut W , } impl < 'a > _BLKLENW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - MMC/SDIO Block Count - SDIO Byte Count" ] # [ inline ] pub fn bcnt ( & self ) -> BCNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BCNTR { bits } } # [ doc = "Bits 16:31 - Data Block Length" ] # [ inline ] pub fn blklen ( & self ) -> BLKLENR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BLKLENR { 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 - MMC/SDIO Block Count - SDIO Byte Count" ] # [ inline ] pub fn bcnt ( & mut self ) -> _BCNTW { _BCNTW { w : self } } # [ doc = "Bits 16:31 - Data Block Length" ] # [ inline ] pub fn blklen ( & mut self ) -> _BLKLENW { _BLKLENW { w : self } } } } # [ doc = "Completion Signal Timeout Register" ] pub struct CSTOR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Completion Signal Timeout Register" ] pub mod cstor { # [ 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 :: CSTOR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CSTOCYCR { bits : u8 , } impl CSTOCYCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `CSTOMUL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CSTOMULR { # [ doc = "CSTOCYC x 1" ] _1 , # [ doc = "CSTOCYC x 16" ] _16 , # [ doc = "CSTOCYC x 128" ] _128 , # [ doc = "CSTOCYC x 256" ] _256 , # [ doc = "CSTOCYC x 1024" ] _1024 , # [ doc = "CSTOCYC x 4096" ] _4096 , # [ doc = "CSTOCYC x 65536" ] _65536 , # [ doc = "CSTOCYC x 1048576" ] _1048576 } impl CSTOMULR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CSTOMULR :: _1 => 0 , CSTOMULR :: _16 => 0x01 , CSTOMULR :: _128 => 0x02 , CSTOMULR :: _256 => 0x03 , CSTOMULR :: _1024 => 0x04 , CSTOMULR :: _4096 => 0x05 , CSTOMULR :: _65536 => 0x06 , CSTOMULR :: _1048576 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CSTOMULR { match value { 0 => CSTOMULR :: _1 , 1 => CSTOMULR :: _16 , 2 => CSTOMULR :: _128 , 3 => CSTOMULR :: _256 , 4 => CSTOMULR :: _1024 , 5 => CSTOMULR :: _4096 , 6 => CSTOMULR :: _65536 , 7 => CSTOMULR :: _1048576 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_1`" ] # [ inline ] pub fn is_1 ( & self ) -> bool { * self == CSTOMULR :: _1 } # [ doc = "Checks if the value of the field is `_16`" ] # [ inline ] pub fn is_16 ( & self ) -> bool { * self == CSTOMULR :: _16 } # [ doc = "Checks if the value of the field is `_128`" ] # [ inline ] pub fn is_128 ( & self ) -> bool { * self == CSTOMULR :: _128 } # [ doc = "Checks if the value of the field is `_256`" ] # [ inline ] pub fn is_256 ( & self ) -> bool { * self == CSTOMULR :: _256 } # [ doc = "Checks if the value of the field is `_1024`" ] # [ inline ] pub fn is_1024 ( & self ) -> bool { * self == CSTOMULR :: _1024 } # [ doc = "Checks if the value of the field is `_4096`" ] # [ inline ] pub fn is_4096 ( & self ) -> bool { * self == CSTOMULR :: _4096 } # [ doc = "Checks if the value of the field is `_65536`" ] # [ inline ] pub fn is_65536 ( & self ) -> bool { * self == CSTOMULR :: _65536 } # [ doc = "Checks if the value of the field is `_1048576`" ] # [ inline ] pub fn is_1048576 ( & self ) -> bool { * self == CSTOMULR :: _1048576 } } # [ doc = r" Proxy" ] pub struct _CSTOCYCW < 'a > { w : & 'a mut W , } impl < 'a > _CSTOCYCW < '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 } } # [ doc = "Values that can be written to the field `CSTOMUL`" ] pub enum CSTOMULW { # [ doc = "CSTOCYC x 1" ] _1 , # [ doc = "CSTOCYC x 16" ] _16 , # [ doc = "CSTOCYC x 128" ] _128 , # [ doc = "CSTOCYC x 256" ] _256 , # [ doc = "CSTOCYC x 1024" ] _1024 , # [ doc = "CSTOCYC x 4096" ] _4096 , # [ doc = "CSTOCYC x 65536" ] _65536 , # [ doc = "CSTOCYC x 1048576" ] _1048576 } impl CSTOMULW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CSTOMULW :: _1 => 0 , CSTOMULW :: _16 => 1 , CSTOMULW :: _128 => 2 , CSTOMULW :: _256 => 3 , CSTOMULW :: _1024 => 4 , CSTOMULW :: _4096 => 5 , CSTOMULW :: _65536 => 6 , CSTOMULW :: _1048576 => 7 } } } # [ doc = r" Proxy" ] pub struct _CSTOMULW < 'a > { w : & 'a mut W , } impl < 'a > _CSTOMULW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CSTOMULW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "CSTOCYC x 1" ] # [ inline ] pub fn _1 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _1 ) } # [ doc = "CSTOCYC x 16" ] # [ inline ] pub fn _16 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _16 ) } # [ doc = "CSTOCYC x 128" ] # [ inline ] pub fn _128 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _128 ) } # [ doc = "CSTOCYC x 256" ] # [ inline ] pub fn _256 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _256 ) } # [ doc = "CSTOCYC x 1024" ] # [ inline ] pub fn _1024 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _1024 ) } # [ doc = "CSTOCYC x 4096" ] # [ inline ] pub fn _4096 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _4096 ) } # [ doc = "CSTOCYC x 65536" ] # [ inline ] pub fn _65536 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _65536 ) } # [ doc = "CSTOCYC x 1048576" ] # [ inline ] pub fn _1048576 ( self ) -> & 'a mut W { self . variant ( CSTOMULW :: _1048576 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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:3 - Completion Signal Timeout Cycle Number" ] # [ inline ] pub fn cstocyc ( & self ) -> CSTOCYCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CSTOCYCR { bits } } # [ doc = "Bits 4:6 - Completion Signal Timeout Multiplier" ] # [ inline ] pub fn cstomul ( & self ) -> CSTOMULR { CSTOMULR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Completion Signal Timeout Cycle Number" ] # [ inline ] pub fn cstocyc ( & mut self ) -> _CSTOCYCW { _CSTOCYCW { w : self } } # [ doc = "Bits 4:6 - Completion Signal Timeout Multiplier" ] # [ inline ] pub fn cstomul ( & mut self ) -> _CSTOMULW { _CSTOMULW { w : self } } } } # [ doc = "Response Register" ] pub struct RSPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Response Register" ] pub mod rspr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RSPR { # [ 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 RSPR { bits : u32 , } impl RSPR { # [ 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 - Response" ] # [ inline ] pub fn rsp ( & self ) -> RSPR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RSPR { bits } } } } # [ doc = "Receive Data Register" ] pub struct RDR { register : :: vcell :: VolatileCell < u32 > } # [ 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 DATAR { bits : u32 , } impl DATAR { # [ 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 - Data to Read" ] # [ inline ] pub fn data ( & self ) -> DATAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DATAR { bits } } } } # [ doc = "Transmit Data Register" ] pub struct TDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Data Register" ] pub mod tdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: TDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DATAW < 'a > { w : & 'a mut W , } impl < 'a > _DATAW < '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 = "Bits 0:31 - Data to Write" ] # [ inline ] pub fn data ( & mut self ) -> _DATAW { _DATAW { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 CMDRDYR { bits : bool , } impl CMDRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BLKER { bits : bool , } impl BLKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTIPR { bits : bool , } impl DTIPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NOTBUSYR { bits : bool , } impl NOTBUSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SDIOIRQFORSLOTAR { bits : bool , } impl SDIOIRQFORSLOTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SDIOIRQFORSLOTBR { bits : bool , } impl SDIOIRQFORSLOTBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SDIOWAITR { bits : bool , } impl SDIOWAITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSRCVR { bits : bool , } impl CSRCVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RINDER { bits : bool , } impl RINDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RDIRER { bits : bool , } impl RDIRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCRCER { bits : bool , } impl RCRCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RENDER { bits : bool , } impl RENDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RTOER { bits : bool , } impl RTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCRCER { bits : bool , } impl DCRCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTOER { bits : bool , } impl DTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSTOER { bits : bool , } impl CSTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BLKOVRER { bits : bool , } impl BLKOVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMADONER { bits : bool , } impl DMADONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FIFOEMPTYR { bits : bool , } impl FIFOEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct XFRDONER { bits : bool , } impl XFRDONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ACKRCVR { bits : bool , } impl ACKRCVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ACKRCVER { bits : bool , } impl ACKRCVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Command Ready" ] # [ inline ] pub fn cmdrdy ( & self ) -> CMDRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMDRDYR { bits } } # [ doc = "Bit 1 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 2 - Transmit Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3 - Data Block Ended" ] # [ inline ] pub fn blke ( & self ) -> BLKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BLKER { bits } } # [ doc = "Bit 4 - Data Transfer in Progress" ] # [ inline ] pub fn dtip ( & self ) -> DTIPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTIPR { bits } } # [ doc = "Bit 5 - HSMCI Not Busy" ] # [ inline ] pub fn notbusy ( & self ) -> NOTBUSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NOTBUSYR { bits } } # [ doc = "Bit 8" ] # [ inline ] pub fn sdioirqfor_slot_a ( & self ) -> SDIOIRQFORSLOTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SDIOIRQFORSLOTAR { bits } } # [ doc = "Bit 9" ] # [ inline ] pub fn sdioirqfor_slot_b ( & self ) -> SDIOIRQFORSLOTBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SDIOIRQFORSLOTBR { bits } } # [ doc = "Bit 12 - SDIO Read Wait Operation Status" ] # [ inline ] pub fn sdiowait ( & self ) -> SDIOWAITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SDIOWAITR { bits } } # [ doc = "Bit 13 - CE-ATA Completion Signal Received" ] # [ inline ] pub fn csrcv ( & self ) -> CSRCVR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSRCVR { bits } } # [ doc = "Bit 16 - Response Index Error" ] # [ inline ] pub fn rinde ( & self ) -> RINDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RINDER { bits } } # [ doc = "Bit 17 - Response Direction Error" ] # [ inline ] pub fn rdire ( & self ) -> RDIRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RDIRER { bits } } # [ doc = "Bit 18 - Response CRC Error" ] # [ inline ] pub fn rcrce ( & self ) -> RCRCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCRCER { bits } } # [ doc = "Bit 19 - Response End Bit Error" ] # [ inline ] pub fn rende ( & self ) -> RENDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RENDER { bits } } # [ doc = "Bit 20 - Response Time-out Error" ] # [ inline ] pub fn rtoe ( & self ) -> RTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTOER { bits } } # [ doc = "Bit 21 - Data CRC Error" ] # [ inline ] pub fn dcrce ( & self ) -> DCRCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCRCER { bits } } # [ doc = "Bit 22 - Data Time-out Error" ] # [ inline ] pub fn dtoe ( & self ) -> DTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTOER { bits } } # [ doc = "Bit 23 - Completion Signal Time-out Error" ] # [ inline ] pub fn cstoe ( & self ) -> CSTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSTOER { bits } } # [ doc = "Bit 24 - DMA Block Overrun Error" ] # [ inline ] pub fn blkovre ( & self ) -> BLKOVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BLKOVRER { bits } } # [ doc = "Bit 25 - DMA Transfer done" ] # [ inline ] pub fn dmadone ( & self ) -> DMADONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMADONER { bits } } # [ doc = "Bit 26 - FIFO empty flag" ] # [ inline ] pub fn fifoempty ( & self ) -> FIFOEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOEMPTYR { bits } } # [ doc = "Bit 27 - Transfer Done flag" ] # [ inline ] pub fn xfrdone ( & self ) -> XFRDONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; XFRDONER { bits } } # [ doc = "Bit 28 - Boot Operation Acknowledge Received" ] # [ inline ] pub fn ackrcv ( & self ) -> ACKRCVR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ACKRCVR { bits } } # [ doc = "Bit 29 - Boot Operation Acknowledge Error" ] # [ inline ] pub fn ackrcve ( & self ) -> ACKRCVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ACKRCVER { bits } } # [ doc = "Bit 30 - Overrun" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 31 - Underrun" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CMDRDYW < 'a > { w : & 'a mut W , } impl < 'a > _CMDRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BLKEW < 'a > { w : & 'a mut W , } impl < 'a > _BLKEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTIPW < 'a > { w : & 'a mut W , } impl < 'a > _DTIPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NOTBUSYW < 'a > { w : & 'a mut W , } impl < 'a > _NOTBUSYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SDIOIRQFORSLOTAW < 'a > { w : & 'a mut W , } impl < 'a > _SDIOIRQFORSLOTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SDIOIRQFORSLOTBW < 'a > { w : & 'a mut W , } impl < 'a > _SDIOIRQFORSLOTBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SDIOWAITW < 'a > { w : & 'a mut W , } impl < 'a > _SDIOWAITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSRCVW < 'a > { w : & 'a mut W , } impl < 'a > _CSRCVW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RINDEW < 'a > { w : & 'a mut W , } impl < 'a > _RINDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RDIREW < 'a > { w : & 'a mut W , } impl < 'a > _RDIREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCRCEW < 'a > { w : & 'a mut W , } impl < 'a > _RCRCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RENDEW < 'a > { w : & 'a mut W , } impl < 'a > _RENDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTOEW < 'a > { w : & 'a mut W , } impl < 'a > _RTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCRCEW < 'a > { w : & 'a mut W , } impl < 'a > _DCRCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTOEW < 'a > { w : & 'a mut W , } impl < 'a > _DTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSTOEW < 'a > { w : & 'a mut W , } impl < 'a > _CSTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BLKOVREW < 'a > { w : & 'a mut W , } impl < 'a > _BLKOVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMADONEW < 'a > { w : & 'a mut W , } impl < 'a > _DMADONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _XFRDONEW < 'a > { w : & 'a mut W , } impl < 'a > _XFRDONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ACKRCVW < 'a > { w : & 'a mut W , } impl < 'a > _ACKRCVW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ACKRCVEW < 'a > { w : & 'a mut W , } impl < 'a > _ACKRCVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Command Ready Interrupt Enable" ] # [ inline ] pub fn cmdrdy ( & mut self ) -> _CMDRDYW { _CMDRDYW { w : self } } # [ doc = "Bit 1 - Receiver Ready Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 2 - Transmit Ready Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3 - Data Block Ended Interrupt Enable" ] # [ inline ] pub fn blke ( & mut self ) -> _BLKEW { _BLKEW { w : self } } # [ doc = "Bit 4 - Data Transfer in Progress Interrupt Enable" ] # [ inline ] pub fn dtip ( & mut self ) -> _DTIPW { _DTIPW { w : self } } # [ doc = "Bit 5 - Data Not Busy Interrupt Enable" ] # [ inline ] pub fn notbusy ( & mut self ) -> _NOTBUSYW { _NOTBUSYW { w : self } } # [ doc = "Bit 8" ] # [ inline ] pub fn sdioirqfor_slot_a ( & mut self ) -> _SDIOIRQFORSLOTAW { _SDIOIRQFORSLOTAW { w : self } } # [ doc = "Bit 9" ] # [ inline ] pub fn sdioirqfor_slot_b ( & mut self ) -> _SDIOIRQFORSLOTBW { _SDIOIRQFORSLOTBW { w : self } } # [ doc = "Bit 12 - SDIO Read Wait Operation Status Interrupt Enable" ] # [ inline ] pub fn sdiowait ( & mut self ) -> _SDIOWAITW { _SDIOWAITW { w : self } } # [ doc = "Bit 13 - Completion Signal Received Interrupt Enable" ] # [ inline ] pub fn csrcv ( & mut self ) -> _CSRCVW { _CSRCVW { w : self } } # [ doc = "Bit 16 - Response Index Error Interrupt Enable" ] # [ inline ] pub fn rinde ( & mut self ) -> _RINDEW { _RINDEW { w : self } } # [ doc = "Bit 17 - Response Direction Error Interrupt Enable" ] # [ inline ] pub fn rdire ( & mut self ) -> _RDIREW { _RDIREW { w : self } } # [ doc = "Bit 18 - Response CRC Error Interrupt Enable" ] # [ inline ] pub fn rcrce ( & mut self ) -> _RCRCEW { _RCRCEW { w : self } } # [ doc = "Bit 19 - Response End Bit Error Interrupt Enable" ] # [ inline ] pub fn rende ( & mut self ) -> _RENDEW { _RENDEW { w : self } } # [ doc = "Bit 20 - Response Time-out Error Interrupt Enable" ] # [ inline ] pub fn rtoe ( & mut self ) -> _RTOEW { _RTOEW { w : self } } # [ doc = "Bit 21 - Data CRC Error Interrupt Enable" ] # [ inline ] pub fn dcrce ( & mut self ) -> _DCRCEW { _DCRCEW { w : self } } # [ doc = "Bit 22 - Data Time-out Error Interrupt Enable" ] # [ inline ] pub fn dtoe ( & mut self ) -> _DTOEW { _DTOEW { w : self } } # [ doc = "Bit 23 - Completion Signal Timeout Error Interrupt Enable" ] # [ inline ] pub fn cstoe ( & mut self ) -> _CSTOEW { _CSTOEW { w : self } } # [ doc = "Bit 24 - DMA Block Overrun Error Interrupt Enable" ] # [ inline ] pub fn blkovre ( & mut self ) -> _BLKOVREW { _BLKOVREW { w : self } } # [ doc = "Bit 25 - DMA Transfer completed Interrupt Enable" ] # [ inline ] pub fn dmadone ( & mut self ) -> _DMADONEW { _DMADONEW { w : self } } # [ doc = "Bit 26 - FIFO empty Interrupt enable" ] # [ inline ] pub fn fifoempty ( & mut self ) -> _FIFOEMPTYW { _FIFOEMPTYW { w : self } } # [ doc = "Bit 27 - Transfer Done Interrupt enable" ] # [ inline ] pub fn xfrdone ( & mut self ) -> _XFRDONEW { _XFRDONEW { w : self } } # [ doc = "Bit 28 - Boot Acknowledge Interrupt Enable" ] # [ inline ] pub fn ackrcv ( & mut self ) -> _ACKRCVW { _ACKRCVW { w : self } } # [ doc = "Bit 29 - Boot Acknowledge Error Interrupt Enable" ] # [ inline ] pub fn ackrcve ( & mut self ) -> _ACKRCVEW { _ACKRCVEW { w : self } } # [ doc = "Bit 30 - Overrun Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 31 - Underrun Interrupt Enable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CMDRDYW < 'a > { w : & 'a mut W , } impl < 'a > _CMDRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BLKEW < 'a > { w : & 'a mut W , } impl < 'a > _BLKEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTIPW < 'a > { w : & 'a mut W , } impl < 'a > _DTIPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NOTBUSYW < 'a > { w : & 'a mut W , } impl < 'a > _NOTBUSYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SDIOIRQFORSLOTAW < 'a > { w : & 'a mut W , } impl < 'a > _SDIOIRQFORSLOTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SDIOIRQFORSLOTBW < 'a > { w : & 'a mut W , } impl < 'a > _SDIOIRQFORSLOTBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SDIOWAITW < 'a > { w : & 'a mut W , } impl < 'a > _SDIOWAITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSRCVW < 'a > { w : & 'a mut W , } impl < 'a > _CSRCVW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RINDEW < 'a > { w : & 'a mut W , } impl < 'a > _RINDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RDIREW < 'a > { w : & 'a mut W , } impl < 'a > _RDIREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCRCEW < 'a > { w : & 'a mut W , } impl < 'a > _RCRCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RENDEW < 'a > { w : & 'a mut W , } impl < 'a > _RENDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTOEW < 'a > { w : & 'a mut W , } impl < 'a > _RTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCRCEW < 'a > { w : & 'a mut W , } impl < 'a > _DCRCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTOEW < 'a > { w : & 'a mut W , } impl < 'a > _DTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSTOEW < 'a > { w : & 'a mut W , } impl < 'a > _CSTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BLKOVREW < 'a > { w : & 'a mut W , } impl < 'a > _BLKOVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMADONEW < 'a > { w : & 'a mut W , } impl < 'a > _DMADONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _XFRDONEW < 'a > { w : & 'a mut W , } impl < 'a > _XFRDONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ACKRCVW < 'a > { w : & 'a mut W , } impl < 'a > _ACKRCVW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ACKRCVEW < 'a > { w : & 'a mut W , } impl < 'a > _ACKRCVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Command Ready Interrupt Disable" ] # [ inline ] pub fn cmdrdy ( & mut self ) -> _CMDRDYW { _CMDRDYW { w : self } } # [ doc = "Bit 1 - Receiver Ready Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 2 - Transmit Ready Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3 - Data Block Ended Interrupt Disable" ] # [ inline ] pub fn blke ( & mut self ) -> _BLKEW { _BLKEW { w : self } } # [ doc = "Bit 4 - Data Transfer in Progress Interrupt Disable" ] # [ inline ] pub fn dtip ( & mut self ) -> _DTIPW { _DTIPW { w : self } } # [ doc = "Bit 5 - Data Not Busy Interrupt Disable" ] # [ inline ] pub fn notbusy ( & mut self ) -> _NOTBUSYW { _NOTBUSYW { w : self } } # [ doc = "Bit 8" ] # [ inline ] pub fn sdioirqfor_slot_a ( & mut self ) -> _SDIOIRQFORSLOTAW { _SDIOIRQFORSLOTAW { w : self } } # [ doc = "Bit 9" ] # [ inline ] pub fn sdioirqfor_slot_b ( & mut self ) -> _SDIOIRQFORSLOTBW { _SDIOIRQFORSLOTBW { w : self } } # [ doc = "Bit 12 - SDIO Read Wait Operation Status Interrupt Disable" ] # [ inline ] pub fn sdiowait ( & mut self ) -> _SDIOWAITW { _SDIOWAITW { w : self } } # [ doc = "Bit 13 - Completion Signal received interrupt Disable" ] # [ inline ] pub fn csrcv ( & mut self ) -> _CSRCVW { _CSRCVW { w : self } } # [ doc = "Bit 16 - Response Index Error Interrupt Disable" ] # [ inline ] pub fn rinde ( & mut self ) -> _RINDEW { _RINDEW { w : self } } # [ doc = "Bit 17 - Response Direction Error Interrupt Disable" ] # [ inline ] pub fn rdire ( & mut self ) -> _RDIREW { _RDIREW { w : self } } # [ doc = "Bit 18 - Response CRC Error Interrupt Disable" ] # [ inline ] pub fn rcrce ( & mut self ) -> _RCRCEW { _RCRCEW { w : self } } # [ doc = "Bit 19 - Response End Bit Error Interrupt Disable" ] # [ inline ] pub fn rende ( & mut self ) -> _RENDEW { _RENDEW { w : self } } # [ doc = "Bit 20 - Response Time-out Error Interrupt Disable" ] # [ inline ] pub fn rtoe ( & mut self ) -> _RTOEW { _RTOEW { w : self } } # [ doc = "Bit 21 - Data CRC Error Interrupt Disable" ] # [ inline ] pub fn dcrce ( & mut self ) -> _DCRCEW { _DCRCEW { w : self } } # [ doc = "Bit 22 - Data Time-out Error Interrupt Disable" ] # [ inline ] pub fn dtoe ( & mut self ) -> _DTOEW { _DTOEW { w : self } } # [ doc = "Bit 23 - Completion Signal Time out Error Interrupt Disable" ] # [ inline ] pub fn cstoe ( & mut self ) -> _CSTOEW { _CSTOEW { w : self } } # [ doc = "Bit 24 - DMA Block Overrun Error Interrupt Disable" ] # [ inline ] pub fn blkovre ( & mut self ) -> _BLKOVREW { _BLKOVREW { w : self } } # [ doc = "Bit 25 - DMA Transfer completed Interrupt Disable" ] # [ inline ] pub fn dmadone ( & mut self ) -> _DMADONEW { _DMADONEW { w : self } } # [ doc = "Bit 26 - FIFO empty Interrupt Disable" ] # [ inline ] pub fn fifoempty ( & mut self ) -> _FIFOEMPTYW { _FIFOEMPTYW { w : self } } # [ doc = "Bit 27 - Transfer Done Interrupt Disable" ] # [ inline ] pub fn xfrdone ( & mut self ) -> _XFRDONEW { _XFRDONEW { w : self } } # [ doc = "Bit 28 - Boot Acknowledge Interrupt Disable" ] # [ inline ] pub fn ackrcv ( & mut self ) -> _ACKRCVW { _ACKRCVW { w : self } } # [ doc = "Bit 29 - Boot Acknowledge Error Interrupt Disable" ] # [ inline ] pub fn ackrcve ( & mut self ) -> _ACKRCVEW { _ACKRCVEW { w : self } } # [ doc = "Bit 30 - Overrun Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 31 - Underrun Interrupt Disable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 CMDRDYR { bits : bool , } impl CMDRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BLKER { bits : bool , } impl BLKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTIPR { bits : bool , } impl DTIPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NOTBUSYR { bits : bool , } impl NOTBUSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SDIOIRQFORSLOTAR { bits : bool , } impl SDIOIRQFORSLOTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SDIOIRQFORSLOTBR { bits : bool , } impl SDIOIRQFORSLOTBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SDIOWAITR { bits : bool , } impl SDIOWAITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSRCVR { bits : bool , } impl CSRCVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RINDER { bits : bool , } impl RINDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RDIRER { bits : bool , } impl RDIRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCRCER { bits : bool , } impl RCRCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RENDER { bits : bool , } impl RENDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RTOER { bits : bool , } impl RTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCRCER { bits : bool , } impl DCRCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTOER { bits : bool , } impl DTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSTOER { bits : bool , } impl CSTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BLKOVRER { bits : bool , } impl BLKOVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMADONER { bits : bool , } impl DMADONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FIFOEMPTYR { bits : bool , } impl FIFOEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct XFRDONER { bits : bool , } impl XFRDONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ACKRCVR { bits : bool , } impl ACKRCVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ACKRCVER { bits : bool , } impl ACKRCVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Command Ready Interrupt Mask" ] # [ inline ] pub fn cmdrdy ( & self ) -> CMDRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMDRDYR { bits } } # [ doc = "Bit 1 - Receiver Ready Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 2 - Transmit Ready Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3 - Data Block Ended Interrupt Mask" ] # [ inline ] pub fn blke ( & self ) -> BLKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BLKER { bits } } # [ doc = "Bit 4 - Data Transfer in Progress Interrupt Mask" ] # [ inline ] pub fn dtip ( & self ) -> DTIPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTIPR { bits } } # [ doc = "Bit 5 - Data Not Busy Interrupt Mask" ] # [ inline ] pub fn notbusy ( & self ) -> NOTBUSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NOTBUSYR { bits } } # [ doc = "Bit 8" ] # [ inline ] pub fn sdioirqfor_slot_a ( & self ) -> SDIOIRQFORSLOTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SDIOIRQFORSLOTAR { bits } } # [ doc = "Bit 9" ] # [ inline ] pub fn sdioirqfor_slot_b ( & self ) -> SDIOIRQFORSLOTBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SDIOIRQFORSLOTBR { bits } } # [ doc = "Bit 12 - SDIO Read Wait Operation Status Interrupt Mask" ] # [ inline ] pub fn sdiowait ( & self ) -> SDIOWAITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SDIOWAITR { bits } } # [ doc = "Bit 13 - Completion Signal Received Interrupt Mask" ] # [ inline ] pub fn csrcv ( & self ) -> CSRCVR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSRCVR { bits } } # [ doc = "Bit 16 - Response Index Error Interrupt Mask" ] # [ inline ] pub fn rinde ( & self ) -> RINDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RINDER { bits } } # [ doc = "Bit 17 - Response Direction Error Interrupt Mask" ] # [ inline ] pub fn rdire ( & self ) -> RDIRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RDIRER { bits } } # [ doc = "Bit 18 - Response CRC Error Interrupt Mask" ] # [ inline ] pub fn rcrce ( & self ) -> RCRCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCRCER { bits } } # [ doc = "Bit 19 - Response End Bit Error Interrupt Mask" ] # [ inline ] pub fn rende ( & self ) -> RENDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RENDER { bits } } # [ doc = "Bit 20 - Response Time-out Error Interrupt Mask" ] # [ inline ] pub fn rtoe ( & self ) -> RTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTOER { bits } } # [ doc = "Bit 21 - Data CRC Error Interrupt Mask" ] # [ inline ] pub fn dcrce ( & self ) -> DCRCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCRCER { bits } } # [ doc = "Bit 22 - Data Time-out Error Interrupt Mask" ] # [ inline ] pub fn dtoe ( & self ) -> DTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTOER { bits } } # [ doc = "Bit 23 - Completion Signal Time-out Error Interrupt Mask" ] # [ inline ] pub fn cstoe ( & self ) -> CSTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSTOER { bits } } # [ doc = "Bit 24 - DMA Block Overrun Error Interrupt Mask" ] # [ inline ] pub fn blkovre ( & self ) -> BLKOVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BLKOVRER { bits } } # [ doc = "Bit 25 - DMA Transfer Completed Interrupt Mask" ] # [ inline ] pub fn dmadone ( & self ) -> DMADONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMADONER { bits } } # [ doc = "Bit 26 - FIFO Empty Interrupt Mask" ] # [ inline ] pub fn fifoempty ( & self ) -> FIFOEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOEMPTYR { bits } } # [ doc = "Bit 27 - Transfer Done Interrupt Mask" ] # [ inline ] pub fn xfrdone ( & self ) -> XFRDONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; XFRDONER { bits } } # [ doc = "Bit 28 - Boot Operation Acknowledge Received Interrupt Mask" ] # [ inline ] pub fn ackrcv ( & self ) -> ACKRCVR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ACKRCVR { bits } } # [ doc = "Bit 29 - Boot Operation Acknowledge Error Interrupt Mask" ] # [ inline ] pub fn ackrcve ( & self ) -> ACKRCVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ACKRCVER { bits } } # [ doc = "Bit 30 - Overrun Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 31 - Underrun Interrupt Mask" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } } } # [ doc = "DMA Configuration Register" ] pub struct DMA { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMA Configuration Register" ] pub mod dma { # [ 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 :: DMA { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 OFFSETR { bits : u8 , } impl OFFSETR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `CHKSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHKSIZER { # [ doc = "1 data available" ] _1 , # [ doc = "4 data available" ] _4 } impl CHKSIZER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { CHKSIZER :: _1 => false , CHKSIZER :: _4 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CHKSIZER { match value { false => CHKSIZER :: _1 , true => CHKSIZER :: _4 , } } # [ doc = "Checks if the value of the field is `_1`" ] # [ inline ] pub fn is_1 ( & self ) -> bool { * self == CHKSIZER :: _1 } # [ doc = "Checks if the value of the field is `_4`" ] # [ inline ] pub fn is_4 ( & self ) -> bool { * self == CHKSIZER :: _4 } } # [ 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 ROPTR { bits : bool , } impl ROPTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _OFFSETW < 'a > { w : & 'a mut W , } impl < 'a > _OFFSETW < '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 = "Values that can be written to the field `CHKSIZE`" ] pub enum CHKSIZEW { # [ doc = "1 data available" ] _1 , # [ doc = "4 data available" ] _4 } impl CHKSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { CHKSIZEW :: _1 => false , CHKSIZEW :: _4 => true } } } # [ doc = r" Proxy" ] pub struct _CHKSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _CHKSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHKSIZEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "1 data available" ] # [ inline ] pub fn _1 ( self ) -> & 'a mut W { self . variant ( CHKSIZEW :: _1 ) } # [ doc = "4 data available" ] # [ inline ] pub fn _4 ( self ) -> & 'a mut W { self . variant ( CHKSIZEW :: _4 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ROPTW < 'a > { w : & 'a mut W , } impl < 'a > _ROPTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - DMA Write Buffer Offset" ] # [ inline ] pub fn offset ( & self ) -> OFFSETR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; OFFSETR { bits } } # [ doc = "Bit 4 - DMA Channel Read and Write Chunk Size" ] # [ inline ] pub fn chksize ( & self ) -> CHKSIZER { CHKSIZER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 8 - DMA Hardware Handshaking Enable" ] # [ inline ] pub fn dmaen ( & self ) -> DMAENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMAENR { bits } } # [ doc = "Bit 12 - Read Optimization with padding" ] # [ inline ] pub fn ropt ( & self ) -> ROPTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ROPTR { 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 - DMA Write Buffer Offset" ] # [ inline ] pub fn offset ( & mut self ) -> _OFFSETW { _OFFSETW { w : self } } # [ doc = "Bit 4 - DMA Channel Read and Write Chunk Size" ] # [ inline ] pub fn chksize ( & mut self ) -> _CHKSIZEW { _CHKSIZEW { w : self } } # [ doc = "Bit 8 - DMA Hardware Handshaking Enable" ] # [ inline ] pub fn dmaen ( & mut self ) -> _DMAENW { _DMAENW { w : self } } # [ doc = "Bit 12 - Read Optimization with padding" ] # [ inline ] pub fn ropt ( & mut self ) -> _ROPTW { _ROPTW { w : self } } } } # [ doc = "Configuration Register" ] pub struct CFG { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Configuration Register" ] pub mod cfg { # [ 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 :: CFG { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FIFOMODER { bits : bool , } impl FIFOMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FERRCTRLR { bits : bool , } impl FERRCTRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HSMODER { bits : bool , } impl HSMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LSYNCR { bits : bool , } impl LSYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _FIFOMODEW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOMODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FERRCTRLW < 'a > { w : & 'a mut W , } impl < 'a > _FERRCTRLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HSMODEW < 'a > { w : & 'a mut W , } impl < 'a > _HSMODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LSYNCW < 'a > { w : & 'a mut W , } impl < 'a > _LSYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - HSMCI Internal FIFO control mode" ] # [ inline ] pub fn fifomode ( & self ) -> FIFOMODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOMODER { bits } } # [ doc = "Bit 4 - Flow Error flag reset control mode" ] # [ inline ] pub fn ferrctrl ( & self ) -> FERRCTRLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FERRCTRLR { bits } } # [ doc = "Bit 8 - High Speed Mode" ] # [ inline ] pub fn hsmode ( & self ) -> HSMODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HSMODER { bits } } # [ doc = "Bit 12 - Synchronize on the last block" ] # [ inline ] pub fn lsync ( & self ) -> LSYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LSYNCR { 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 - HSMCI Internal FIFO control mode" ] # [ inline ] pub fn fifomode ( & mut self ) -> _FIFOMODEW { _FIFOMODEW { w : self } } # [ doc = "Bit 4 - Flow Error flag reset control mode" ] # [ inline ] pub fn ferrctrl ( & mut self ) -> _FERRCTRLW { _FERRCTRLW { w : self } } # [ doc = "Bit 8 - High Speed Mode" ] # [ inline ] pub fn hsmode ( & mut self ) -> _HSMODEW { _HSMODEW { w : self } } # [ doc = "Bit 12 - Synchronize on the last block" ] # [ inline ] pub fn lsync ( & mut self ) -> _LSYNCW { _LSYNCW { w : self } } } } # [ doc = "Write Protection Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x004d_4349 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5063497 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5063497 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect Key" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } impl W { # [ doc = "Bit 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect Key" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protection Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "FIFO Memory Aperture0" ] pub struct FIFO { register : :: vcell :: VolatileCell < u32 > } # [ doc = "FIFO Memory Aperture0" ] pub mod fifo { # [ 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 :: FIFO { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 DATAR { bits : u32 , } impl DATAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DATAW < 'a > { w : & 'a mut W , } impl < 'a > _DATAW < '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 to Read or Data to Write" ] # [ inline ] pub fn data ( & self ) -> DATAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DATAR { bits } } } impl W { # [ doc = "Bits 0:31 - Data to Read or Data to Write" ] # [ inline ] pub fn data ( & mut self ) -> _DATAW { _DATAW { w : self } } } } } # [ doc = "Synchronous Serial Controller" ] pub struct SSC { _marker : PhantomData < * const ( ) > } unsafe impl Send for SSC { } impl SSC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const ssc :: RegisterBlock { 0x4000_4000 as * const _ } } impl Deref for SSC { type Target = ssc :: RegisterBlock ; fn deref ( & self ) -> & ssc :: RegisterBlock { unsafe { & * SSC :: ptr ( ) } } } # [ doc = "Synchronous Serial Controller" ] pub mod ssc { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Clock Mode Register" ] pub cmr : CMR , _reserved2 : [ u8 ; 8usize ] , # [ doc = "0x10 - Receive Clock Mode Register" ] pub rcmr : RCMR , # [ doc = "0x14 - Receive Frame Mode Register" ] pub rfmr : RFMR , # [ doc = "0x18 - Transmit Clock Mode Register" ] pub tcmr : TCMR , # [ doc = "0x1c - Transmit Frame Mode Register" ] pub tfmr : TFMR , # [ doc = "0x20 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x24 - Transmit Holding Register" ] pub thr : THR , _reserved8 : [ u8 ; 8usize ] , # [ doc = "0x30 - Receive Sync. Holding Register" ] pub rshr : RSHR , # [ doc = "0x34 - Transmit Sync. Holding Register" ] pub tshr : TSHR , # [ doc = "0x38 - Receive Compare 0 Register" ] pub rc0r : RC0R , # [ doc = "0x3c - Receive Compare 1 Register" ] pub rc1r : RC1R , # [ doc = "0x40 - Status Register" ] pub sr : SR , # [ doc = "0x44 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x48 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x4c - Interrupt Mask Register" ] pub imr : IMR , _reserved16 : [ u8 ; 148usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 15 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bit 0 - Receive Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 1 - Receive Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 8 - Transmit Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 9 - Transmit Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 15 - Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } } } # [ doc = "Clock Mode Register" ] pub struct CMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Clock Mode Register" ] pub mod cmr { # [ 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 :: CMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DIVR { bits : u16 , } impl DIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DIVW < 'a > { w : & 'a mut W , } impl < 'a > _DIVW < '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 - Clock Divider" ] # [ inline ] pub fn div ( & self ) -> DIVR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DIVR { 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 - Clock Divider" ] # [ inline ] pub fn div ( & mut self ) -> _DIVW { _DIVW { w : self } } } } # [ doc = "Receive Clock Mode Register" ] pub struct RCMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Clock Mode Register" ] pub mod rcmr { # [ 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 :: RCMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CKSR { # [ doc = "Divided Clock" ] MCK , # [ doc = "TK Clock signal" ] TK , # [ doc = "RK pin" ] RK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CKSR :: MCK => 0 , CKSR :: TK => 0x01 , CKSR :: RK => 0x02 , CKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CKSR { match value { 0 => CKSR :: MCK , 1 => CKSR :: TK , 2 => CKSR :: RK , i => CKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CKSR :: MCK } # [ doc = "Checks if the value of the field is `TK`" ] # [ inline ] pub fn is_tk ( & self ) -> bool { * self == CKSR :: TK } # [ doc = "Checks if the value of the field is `RK`" ] # [ inline ] pub fn is_rk ( & self ) -> bool { * self == CKSR :: RK } } # [ doc = "Possible values of the field `CKO`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CKOR { # [ doc = "None, RK pin is an input" ] NONE , # [ doc = "Continuous Receive Clock, RK pin is an output" ] CONTINUOUS , # [ doc = "Receive Clock only during data transfers, RK pin is an output" ] TRANSFER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CKOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CKOR :: NONE => 0 , CKOR :: CONTINUOUS => 0x01 , CKOR :: TRANSFER => 0x02 , CKOR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CKOR { match value { 0 => CKOR :: NONE , 1 => CKOR :: CONTINUOUS , 2 => CKOR :: TRANSFER , i => CKOR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == CKOR :: NONE } # [ doc = "Checks if the value of the field is `CONTINUOUS`" ] # [ inline ] pub fn is_continuous ( & self ) -> bool { * self == CKOR :: CONTINUOUS } # [ doc = "Checks if the value of the field is `TRANSFER`" ] # [ inline ] pub fn is_transfer ( & self ) -> bool { * self == CKOR :: TRANSFER } } # [ doc = r" Value of the field" ] pub struct CKIR { bits : bool , } impl CKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `CKG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CKGR { # [ doc = "None" ] CONTINUOUS , # [ doc = "Receive Clock enabled only if RF Low" ] EN_RF_LOW , # [ doc = "Receive Clock enabled only if RF High" ] EN_RF_HIGH , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CKGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CKGR :: CONTINUOUS => 0 , CKGR :: EN_RF_LOW => 0x01 , CKGR :: EN_RF_HIGH => 0x02 , CKGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CKGR { match value { 0 => CKGR :: CONTINUOUS , 1 => CKGR :: EN_RF_LOW , 2 => CKGR :: EN_RF_HIGH , i => CKGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CONTINUOUS`" ] # [ inline ] pub fn is_continuous ( & self ) -> bool { * self == CKGR :: CONTINUOUS } # [ doc = "Checks if the value of the field is `EN_RF_LOW`" ] # [ inline ] pub fn is_en_rf_low ( & self ) -> bool { * self == CKGR :: EN_RF_LOW } # [ doc = "Checks if the value of the field is `EN_RF_HIGH`" ] # [ inline ] pub fn is_en_rf_high ( & self ) -> bool { * self == CKGR :: EN_RF_HIGH } } # [ doc = "Possible values of the field `START`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum STARTR { # [ doc = "Continuous, as soon as the receiver is enabled, and immediately after the end of transfer of the previous data." ] CONTINUOUS , # [ doc = "Transmit start" ] TRANSMIT , # [ doc = "Detection of a low level on RF signal" ] RF_LOW , # [ doc = "Detection of a high level on RF signal" ] RF_HIGH , # [ doc = "Detection of a falling edge on RF signal" ] RF_FALLING , # [ doc = "Detection of a rising edge on RF signal" ] RF_RISING , # [ doc = "Detection of any level change on RF signal" ] RF_LEVEL , # [ doc = "Detection of any edge on RF signal" ] RF_EDGE , # [ doc = "Compare 0" ] CMP_0 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl STARTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { STARTR :: CONTINUOUS => 0 , STARTR :: TRANSMIT => 0x01 , STARTR :: RF_LOW => 0x02 , STARTR :: RF_HIGH => 0x03 , STARTR :: RF_FALLING => 0x04 , STARTR :: RF_RISING => 0x05 , STARTR :: RF_LEVEL => 0x06 , STARTR :: RF_EDGE => 0x07 , STARTR :: CMP_0 => 0x08 , STARTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> STARTR { match value { 0 => STARTR :: CONTINUOUS , 1 => STARTR :: TRANSMIT , 2 => STARTR :: RF_LOW , 3 => STARTR :: RF_HIGH , 4 => STARTR :: RF_FALLING , 5 => STARTR :: RF_RISING , 6 => STARTR :: RF_LEVEL , 7 => STARTR :: RF_EDGE , 8 => STARTR :: CMP_0 , i => STARTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CONTINUOUS`" ] # [ inline ] pub fn is_continuous ( & self ) -> bool { * self == STARTR :: CONTINUOUS } # [ doc = "Checks if the value of the field is `TRANSMIT`" ] # [ inline ] pub fn is_transmit ( & self ) -> bool { * self == STARTR :: TRANSMIT } # [ doc = "Checks if the value of the field is `RF_LOW`" ] # [ inline ] pub fn is_rf_low ( & self ) -> bool { * self == STARTR :: RF_LOW } # [ doc = "Checks if the value of the field is `RF_HIGH`" ] # [ inline ] pub fn is_rf_high ( & self ) -> bool { * self == STARTR :: RF_HIGH } # [ doc = "Checks if the value of the field is `RF_FALLING`" ] # [ inline ] pub fn is_rf_falling ( & self ) -> bool { * self == STARTR :: RF_FALLING } # [ doc = "Checks if the value of the field is `RF_RISING`" ] # [ inline ] pub fn is_rf_rising ( & self ) -> bool { * self == STARTR :: RF_RISING } # [ doc = "Checks if the value of the field is `RF_LEVEL`" ] # [ inline ] pub fn is_rf_level ( & self ) -> bool { * self == STARTR :: RF_LEVEL } # [ doc = "Checks if the value of the field is `RF_EDGE`" ] # [ inline ] pub fn is_rf_edge ( & self ) -> bool { * self == STARTR :: RF_EDGE } # [ doc = "Checks if the value of the field is `CMP_0`" ] # [ inline ] pub fn is_cmp_0 ( & self ) -> bool { * self == STARTR :: CMP_0 } } # [ 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 STTDLYR { bits : u8 , } impl STTDLYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PERIODR { bits : u8 , } impl PERIODR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Values that can be written to the field `CKS`" ] pub enum CKSW { # [ doc = "Divided Clock" ] MCK , # [ doc = "TK Clock signal" ] TK , # [ doc = "RK pin" ] RK } impl CKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CKSW :: MCK => 0 , CKSW :: TK => 1 , CKSW :: RK => 2 } } } # [ doc = r" Proxy" ] pub struct _CKSW < 'a > { w : & 'a mut W , } impl < 'a > _CKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Divided Clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CKSW :: MCK ) } # [ doc = "TK Clock signal" ] # [ inline ] pub fn tk ( self ) -> & 'a mut W { self . variant ( CKSW :: TK ) } # [ doc = "RK pin" ] # [ inline ] pub fn rk ( self ) -> & 'a mut W { self . variant ( CKSW :: RK ) } # [ 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 = "Values that can be written to the field `CKO`" ] pub enum CKOW { # [ doc = "None, RK pin is an input" ] NONE , # [ doc = "Continuous Receive Clock, RK pin is an output" ] CONTINUOUS , # [ doc = "Receive Clock only during data transfers, RK pin is an output" ] TRANSFER } impl CKOW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CKOW :: NONE => 0 , CKOW :: CONTINUOUS => 1 , CKOW :: TRANSFER => 2 } } } # [ doc = r" Proxy" ] pub struct _CKOW < 'a > { w : & 'a mut W , } impl < 'a > _CKOW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CKOW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "None, RK pin is an input" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( CKOW :: NONE ) } # [ doc = "Continuous Receive Clock, RK pin is an output" ] # [ inline ] pub fn continuous ( self ) -> & 'a mut W { self . variant ( CKOW :: CONTINUOUS ) } # [ doc = "Receive Clock only during data transfers, RK pin is an output" ] # [ inline ] pub fn transfer ( self ) -> & 'a mut W { self . variant ( CKOW :: TRANSFER ) } # [ 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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CKIW < 'a > { w : & 'a mut W , } impl < 'a > _CKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `CKG`" ] pub enum CKGW { # [ doc = "None" ] CONTINUOUS , # [ doc = "Receive Clock enabled only if RF Low" ] EN_RF_LOW , # [ doc = "Receive Clock enabled only if RF High" ] EN_RF_HIGH } impl CKGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CKGW :: CONTINUOUS => 0 , CKGW :: EN_RF_LOW => 1 , CKGW :: EN_RF_HIGH => 2 } } } # [ doc = r" Proxy" ] pub struct _CKGW < 'a > { w : & 'a mut W , } impl < 'a > _CKGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CKGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn continuous ( self ) -> & 'a mut W { self . variant ( CKGW :: CONTINUOUS ) } # [ doc = "Receive Clock enabled only if RF Low" ] # [ inline ] pub fn en_rf_low ( self ) -> & 'a mut W { self . variant ( CKGW :: EN_RF_LOW ) } # [ doc = "Receive Clock enabled only if RF High" ] # [ inline ] pub fn en_rf_high ( self ) -> & 'a mut W { self . variant ( CKGW :: EN_RF_HIGH ) } # [ 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 = "Values that can be written to the field `START`" ] pub enum STARTW { # [ doc = "Continuous, as soon as the receiver is enabled, and immediately after the end of transfer of the previous data." ] CONTINUOUS , # [ doc = "Transmit start" ] TRANSMIT , # [ doc = "Detection of a low level on RF signal" ] RF_LOW , # [ doc = "Detection of a high level on RF signal" ] RF_HIGH , # [ doc = "Detection of a falling edge on RF signal" ] RF_FALLING , # [ doc = "Detection of a rising edge on RF signal" ] RF_RISING , # [ doc = "Detection of any level change on RF signal" ] RF_LEVEL , # [ doc = "Detection of any edge on RF signal" ] RF_EDGE , # [ doc = "Compare 0" ] CMP_0 } impl STARTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { STARTW :: CONTINUOUS => 0 , STARTW :: TRANSMIT => 1 , STARTW :: RF_LOW => 2 , STARTW :: RF_HIGH => 3 , STARTW :: RF_FALLING => 4 , STARTW :: RF_RISING => 5 , STARTW :: RF_LEVEL => 6 , STARTW :: RF_EDGE => 7 , STARTW :: CMP_0 => 8 } } } # [ doc = r" Proxy" ] pub struct _STARTW < 'a > { w : & 'a mut W , } impl < 'a > _STARTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : STARTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Continuous, as soon as the receiver is enabled, and immediately after the end of transfer of the previous data." ] # [ inline ] pub fn continuous ( self ) -> & 'a mut W { self . variant ( STARTW :: CONTINUOUS ) } # [ doc = "Transmit start" ] # [ inline ] pub fn transmit ( self ) -> & 'a mut W { self . variant ( STARTW :: TRANSMIT ) } # [ doc = "Detection of a low level on RF signal" ] # [ inline ] pub fn rf_low ( self ) -> & 'a mut W { self . variant ( STARTW :: RF_LOW ) } # [ doc = "Detection of a high level on RF signal" ] # [ inline ] pub fn rf_high ( self ) -> & 'a mut W { self . variant ( STARTW :: RF_HIGH ) } # [ doc = "Detection of a falling edge on RF signal" ] # [ inline ] pub fn rf_falling ( self ) -> & 'a mut W { self . variant ( STARTW :: RF_FALLING ) } # [ doc = "Detection of a rising edge on RF signal" ] # [ inline ] pub fn rf_rising ( self ) -> & 'a mut W { self . variant ( STARTW :: RF_RISING ) } # [ doc = "Detection of any level change on RF signal" ] # [ inline ] pub fn rf_level ( self ) -> & 'a mut W { self . variant ( STARTW :: RF_LEVEL ) } # [ doc = "Detection of any edge on RF signal" ] # [ inline ] pub fn rf_edge ( self ) -> & 'a mut W { self . variant ( STARTW :: RF_EDGE ) } # [ doc = "Compare 0" ] # [ inline ] pub fn cmp_0 ( self ) -> & 'a mut W { self . variant ( STARTW :: CMP_0 ) } # [ 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 _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 = 12 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _STTDLYW < 'a > { w : & 'a mut W , } impl < 'a > _STTDLYW < '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 _PERIODW < 'a > { w : & 'a mut W , } impl < 'a > _PERIODW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Receive Clock Selection" ] # [ inline ] pub fn cks ( & self ) -> CKSR { CKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 2:4 - Receive Clock Output Mode Selection" ] # [ inline ] pub fn cko ( & self ) -> CKOR { CKOR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 5 - Receive Clock Inversion" ] # [ inline ] pub fn cki ( & self ) -> CKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CKIR { bits } } # [ doc = "Bits 6:7 - Receive Clock Gating Selection" ] # [ inline ] pub fn ckg ( & self ) -> CKGR { CKGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 8:11 - Receive Start Selection" ] # [ inline ] pub fn start ( & self ) -> STARTR { STARTR :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Receive Stop Selection" ] # [ inline ] pub fn stop ( & self ) -> STOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STOPR { bits } } # [ doc = "Bits 16:23 - Receive Start Delay" ] # [ inline ] pub fn sttdly ( & self ) -> STTDLYR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; STTDLYR { bits } } # [ doc = "Bits 24:31 - Receive Period Divider Selection" ] # [ inline ] pub fn period ( & self ) -> PERIODR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PERIODR { 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 - Receive Clock Selection" ] # [ inline ] pub fn cks ( & mut self ) -> _CKSW { _CKSW { w : self } } # [ doc = "Bits 2:4 - Receive Clock Output Mode Selection" ] # [ inline ] pub fn cko ( & mut self ) -> _CKOW { _CKOW { w : self } } # [ doc = "Bit 5 - Receive Clock Inversion" ] # [ inline ] pub fn cki ( & mut self ) -> _CKIW { _CKIW { w : self } } # [ doc = "Bits 6:7 - Receive Clock Gating Selection" ] # [ inline ] pub fn ckg ( & mut self ) -> _CKGW { _CKGW { w : self } } # [ doc = "Bits 8:11 - Receive Start Selection" ] # [ inline ] pub fn start ( & mut self ) -> _STARTW { _STARTW { w : self } } # [ doc = "Bit 12 - Receive Stop Selection" ] # [ inline ] pub fn stop ( & mut self ) -> _STOPW { _STOPW { w : self } } # [ doc = "Bits 16:23 - Receive Start Delay" ] # [ inline ] pub fn sttdly ( & mut self ) -> _STTDLYW { _STTDLYW { w : self } } # [ doc = "Bits 24:31 - Receive Period Divider Selection" ] # [ inline ] pub fn period ( & mut self ) -> _PERIODW { _PERIODW { w : self } } } } # [ doc = "Receive Frame Mode Register" ] pub struct RFMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Frame Mode Register" ] pub mod rfmr { # [ 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 :: RFMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 LOOPR { bits : bool , } impl LOOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MSBFR { bits : bool , } impl MSBFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DATNBR { bits : u8 , } impl DATNBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FSLENR { bits : u8 , } impl FSLENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FSOS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FSOSR { # [ doc = "None, RF pin is an input" ] NONE , # [ doc = "Negative Pulse, RF pin is an output" ] NEGATIVE , # [ doc = "Positive Pulse, RF pin is an output" ] POSITIVE , # [ doc = "Driven Low during data transfer, RF pin is an output" ] LOW , # [ doc = "Driven High during data transfer, RF pin is an output" ] HIGH , # [ doc = "Toggling at each start of data transfer, RF pin is an output" ] TOGGLING , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FSOSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FSOSR :: NONE => 0 , FSOSR :: NEGATIVE => 0x01 , FSOSR :: POSITIVE => 0x02 , FSOSR :: LOW => 0x03 , FSOSR :: HIGH => 0x04 , FSOSR :: TOGGLING => 0x05 , FSOSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FSOSR { match value { 0 => FSOSR :: NONE , 1 => FSOSR :: NEGATIVE , 2 => FSOSR :: POSITIVE , 3 => FSOSR :: LOW , 4 => FSOSR :: HIGH , 5 => FSOSR :: TOGGLING , i => FSOSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == FSOSR :: NONE } # [ doc = "Checks if the value of the field is `NEGATIVE`" ] # [ inline ] pub fn is_negative ( & self ) -> bool { * self == FSOSR :: NEGATIVE } # [ doc = "Checks if the value of the field is `POSITIVE`" ] # [ inline ] pub fn is_positive ( & self ) -> bool { * self == FSOSR :: POSITIVE } # [ doc = "Checks if the value of the field is `LOW`" ] # [ inline ] pub fn is_low ( & self ) -> bool { * self == FSOSR :: LOW } # [ doc = "Checks if the value of the field is `HIGH`" ] # [ inline ] pub fn is_high ( & self ) -> bool { * self == FSOSR :: HIGH } # [ doc = "Checks if the value of the field is `TOGGLING`" ] # [ inline ] pub fn is_toggling ( & self ) -> bool { * self == FSOSR :: TOGGLING } } # [ doc = "Possible values of the field `FSEDGE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FSEDGER { # [ doc = "Positive Edge Detection" ] POSITIVE , # [ doc = "Negative Edge Detection" ] NEGATIVE } impl FSEDGER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { FSEDGER :: POSITIVE => false , FSEDGER :: NEGATIVE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> FSEDGER { match value { false => FSEDGER :: POSITIVE , true => FSEDGER :: NEGATIVE , } } # [ doc = "Checks if the value of the field is `POSITIVE`" ] # [ inline ] pub fn is_positive ( & self ) -> bool { * self == FSEDGER :: POSITIVE } # [ doc = "Checks if the value of the field is `NEGATIVE`" ] # [ inline ] pub fn is_negative ( & self ) -> bool { * self == FSEDGER :: NEGATIVE } } # [ doc = r" Value of the field" ] pub struct FSLEN_EXTR { bits : u8 , } impl FSLEN_EXTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 = 0x1f ; 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 _LOOPW < 'a > { w : & 'a mut W , } impl < 'a > _LOOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSBFW < 'a > { w : & 'a mut W , } impl < 'a > _MSBFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DATNBW < 'a > { w : & 'a mut W , } impl < 'a > _DATNBW < '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 _FSLENW < 'a > { w : & 'a mut W , } impl < 'a > _FSLENW < '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 = "Values that can be written to the field `FSOS`" ] pub enum FSOSW { # [ doc = "None, RF pin is an input" ] NONE , # [ doc = "Negative Pulse, RF pin is an output" ] NEGATIVE , # [ doc = "Positive Pulse, RF pin is an output" ] POSITIVE , # [ doc = "Driven Low during data transfer, RF pin is an output" ] LOW , # [ doc = "Driven High during data transfer, RF pin is an output" ] HIGH , # [ doc = "Toggling at each start of data transfer, RF pin is an output" ] TOGGLING } impl FSOSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FSOSW :: NONE => 0 , FSOSW :: NEGATIVE => 1 , FSOSW :: POSITIVE => 2 , FSOSW :: LOW => 3 , FSOSW :: HIGH => 4 , FSOSW :: TOGGLING => 5 } } } # [ doc = r" Proxy" ] pub struct _FSOSW < 'a > { w : & 'a mut W , } impl < 'a > _FSOSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FSOSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "None, RF pin is an input" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( FSOSW :: NONE ) } # [ doc = "Negative Pulse, RF pin is an output" ] # [ inline ] pub fn negative ( self ) -> & 'a mut W { self . variant ( FSOSW :: NEGATIVE ) } # [ doc = "Positive Pulse, RF pin is an output" ] # [ inline ] pub fn positive ( self ) -> & 'a mut W { self . variant ( FSOSW :: POSITIVE ) } # [ doc = "Driven Low during data transfer, RF pin is an output" ] # [ inline ] pub fn low ( self ) -> & 'a mut W { self . variant ( FSOSW :: LOW ) } # [ doc = "Driven High during data transfer, RF pin is an output" ] # [ inline ] pub fn high ( self ) -> & 'a mut W { self . variant ( FSOSW :: HIGH ) } # [ doc = "Toggling at each start of data transfer, RF pin is an output" ] # [ inline ] pub fn toggling ( self ) -> & 'a mut W { self . variant ( FSOSW :: TOGGLING ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `FSEDGE`" ] pub enum FSEDGEW { # [ doc = "Positive Edge Detection" ] POSITIVE , # [ doc = "Negative Edge Detection" ] NEGATIVE } impl FSEDGEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { FSEDGEW :: POSITIVE => false , FSEDGEW :: NEGATIVE => true } } } # [ doc = r" Proxy" ] pub struct _FSEDGEW < 'a > { w : & 'a mut W , } impl < 'a > _FSEDGEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FSEDGEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Positive Edge Detection" ] # [ inline ] pub fn positive ( self ) -> & 'a mut W { self . variant ( FSEDGEW :: POSITIVE ) } # [ doc = "Negative Edge Detection" ] # [ inline ] pub fn negative ( self ) -> & 'a mut W { self . variant ( FSEDGEW :: NEGATIVE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSLEN_EXTW < 'a > { w : & 'a mut W , } impl < 'a > _FSLEN_EXTW < '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:4 - Data Length" ] # [ inline ] pub fn datlen ( & self ) -> DATLENR { let bits = { const MASK : u8 = 0x1f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DATLENR { bits } } # [ doc = "Bit 5 - Loop Mode" ] # [ inline ] pub fn loop_ ( & self ) -> LOOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOOPR { bits } } # [ doc = "Bit 7 - Most Significant Bit First" ] # [ inline ] pub fn msbf ( & self ) -> MSBFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSBFR { bits } } # [ doc = "Bits 8:11 - Data Number per Frame" ] # [ inline ] pub fn datnb ( & self ) -> DATNBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DATNBR { bits } } # [ doc = "Bits 16:19 - Receive Frame Sync Length" ] # [ inline ] pub fn fslen ( & self ) -> FSLENR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FSLENR { bits } } # [ doc = "Bits 20:22 - Receive Frame Sync Output Selection" ] # [ inline ] pub fn fsos ( & self ) -> FSOSR { FSOSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 24 - Frame Sync Edge Detection" ] # [ inline ] pub fn fsedge ( & self ) -> FSEDGER { FSEDGER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 28:31 - FSLEN Field Extension" ] # [ inline ] pub fn fslen_ext ( & self ) -> FSLEN_EXTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FSLEN_EXTR { 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:4 - Data Length" ] # [ inline ] pub fn datlen ( & mut self ) -> _DATLENW { _DATLENW { w : self } } # [ doc = "Bit 5 - Loop Mode" ] # [ inline ] pub fn loop_ ( & mut self ) -> _LOOPW { _LOOPW { w : self } } # [ doc = "Bit 7 - Most Significant Bit First" ] # [ inline ] pub fn msbf ( & mut self ) -> _MSBFW { _MSBFW { w : self } } # [ doc = "Bits 8:11 - Data Number per Frame" ] # [ inline ] pub fn datnb ( & mut self ) -> _DATNBW { _DATNBW { w : self } } # [ doc = "Bits 16:19 - Receive Frame Sync Length" ] # [ inline ] pub fn fslen ( & mut self ) -> _FSLENW { _FSLENW { w : self } } # [ doc = "Bits 20:22 - Receive Frame Sync Output Selection" ] # [ inline ] pub fn fsos ( & mut self ) -> _FSOSW { _FSOSW { w : self } } # [ doc = "Bit 24 - Frame Sync Edge Detection" ] # [ inline ] pub fn fsedge ( & mut self ) -> _FSEDGEW { _FSEDGEW { w : self } } # [ doc = "Bits 28:31 - FSLEN Field Extension" ] # [ inline ] pub fn fslen_ext ( & mut self ) -> _FSLEN_EXTW { _FSLEN_EXTW { w : self } } } } # [ doc = "Transmit Clock Mode Register" ] pub struct TCMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Clock Mode Register" ] pub mod tcmr { # [ 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 :: TCMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CKSR { # [ doc = "Divided Clock" ] MCK , # [ doc = "RK Clock signal" ] RK , # [ doc = "TK pin" ] TK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CKSR :: MCK => 0 , CKSR :: RK => 0x01 , CKSR :: TK => 0x02 , CKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CKSR { match value { 0 => CKSR :: MCK , 1 => CKSR :: RK , 2 => CKSR :: TK , i => CKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CKSR :: MCK } # [ doc = "Checks if the value of the field is `RK`" ] # [ inline ] pub fn is_rk ( & self ) -> bool { * self == CKSR :: RK } # [ doc = "Checks if the value of the field is `TK`" ] # [ inline ] pub fn is_tk ( & self ) -> bool { * self == CKSR :: TK } } # [ doc = "Possible values of the field `CKO`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CKOR { # [ doc = "None, TK pin is an input" ] NONE , # [ doc = "Continuous Transmit Clock, TK pin is an output" ] CONTINUOUS , # [ doc = "Transmit Clock only during data transfers, TK pin is an output" ] TRANSFER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CKOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CKOR :: NONE => 0 , CKOR :: CONTINUOUS => 0x01 , CKOR :: TRANSFER => 0x02 , CKOR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CKOR { match value { 0 => CKOR :: NONE , 1 => CKOR :: CONTINUOUS , 2 => CKOR :: TRANSFER , i => CKOR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == CKOR :: NONE } # [ doc = "Checks if the value of the field is `CONTINUOUS`" ] # [ inline ] pub fn is_continuous ( & self ) -> bool { * self == CKOR :: CONTINUOUS } # [ doc = "Checks if the value of the field is `TRANSFER`" ] # [ inline ] pub fn is_transfer ( & self ) -> bool { * self == CKOR :: TRANSFER } } # [ doc = r" Value of the field" ] pub struct CKIR { bits : bool , } impl CKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `CKG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CKGR { # [ doc = "None" ] CONTINUOUS , # [ doc = "Transmit Clock enabled only if TF Low" ] EN_TF_LOW , # [ doc = "Transmit Clock enabled only if TF High" ] EN_TF_HIGH , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CKGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CKGR :: CONTINUOUS => 0 , CKGR :: EN_TF_LOW => 0x01 , CKGR :: EN_TF_HIGH => 0x02 , CKGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CKGR { match value { 0 => CKGR :: CONTINUOUS , 1 => CKGR :: EN_TF_LOW , 2 => CKGR :: EN_TF_HIGH , i => CKGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CONTINUOUS`" ] # [ inline ] pub fn is_continuous ( & self ) -> bool { * self == CKGR :: CONTINUOUS } # [ doc = "Checks if the value of the field is `EN_TF_LOW`" ] # [ inline ] pub fn is_en_tf_low ( & self ) -> bool { * self == CKGR :: EN_TF_LOW } # [ doc = "Checks if the value of the field is `EN_TF_HIGH`" ] # [ inline ] pub fn is_en_tf_high ( & self ) -> bool { * self == CKGR :: EN_TF_HIGH } } # [ doc = "Possible values of the field `START`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum STARTR { # [ doc = "Continuous, as soon as a word is written in the SSC_THR Register (if Transmit is enabled), and immediately after the end of transfer of the previous data" ] CONTINUOUS , # [ doc = "Receive start" ] RECEIVE , # [ doc = "Detection of a low level on TF signal" ] TF_LOW , # [ doc = "Detection of a high level on TF signal" ] TF_HIGH , # [ doc = "Detection of a falling edge on TF signal" ] TF_FALLING , # [ doc = "Detection of a rising edge on TF signal" ] TF_RISING , # [ doc = "Detection of any level change on TF signal" ] TF_LEVEL , # [ doc = "Detection of any edge on TF signal" ] TF_EDGE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl STARTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { STARTR :: CONTINUOUS => 0 , STARTR :: RECEIVE => 0x01 , STARTR :: TF_LOW => 0x02 , STARTR :: TF_HIGH => 0x03 , STARTR :: TF_FALLING => 0x04 , STARTR :: TF_RISING => 0x05 , STARTR :: TF_LEVEL => 0x06 , STARTR :: TF_EDGE => 0x07 , STARTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> STARTR { match value { 0 => STARTR :: CONTINUOUS , 1 => STARTR :: RECEIVE , 2 => STARTR :: TF_LOW , 3 => STARTR :: TF_HIGH , 4 => STARTR :: TF_FALLING , 5 => STARTR :: TF_RISING , 6 => STARTR :: TF_LEVEL , 7 => STARTR :: TF_EDGE , i => STARTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CONTINUOUS`" ] # [ inline ] pub fn is_continuous ( & self ) -> bool { * self == STARTR :: CONTINUOUS } # [ doc = "Checks if the value of the field is `RECEIVE`" ] # [ inline ] pub fn is_receive ( & self ) -> bool { * self == STARTR :: RECEIVE } # [ doc = "Checks if the value of the field is `TF_LOW`" ] # [ inline ] pub fn is_tf_low ( & self ) -> bool { * self == STARTR :: TF_LOW } # [ doc = "Checks if the value of the field is `TF_HIGH`" ] # [ inline ] pub fn is_tf_high ( & self ) -> bool { * self == STARTR :: TF_HIGH } # [ doc = "Checks if the value of the field is `TF_FALLING`" ] # [ inline ] pub fn is_tf_falling ( & self ) -> bool { * self == STARTR :: TF_FALLING } # [ doc = "Checks if the value of the field is `TF_RISING`" ] # [ inline ] pub fn is_tf_rising ( & self ) -> bool { * self == STARTR :: TF_RISING } # [ doc = "Checks if the value of the field is `TF_LEVEL`" ] # [ inline ] pub fn is_tf_level ( & self ) -> bool { * self == STARTR :: TF_LEVEL } # [ doc = "Checks if the value of the field is `TF_EDGE`" ] # [ inline ] pub fn is_tf_edge ( & self ) -> bool { * self == STARTR :: TF_EDGE } } # [ doc = r" Value of the field" ] pub struct STTDLYR { bits : u8 , } impl STTDLYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PERIODR { bits : u8 , } impl PERIODR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Values that can be written to the field `CKS`" ] pub enum CKSW { # [ doc = "Divided Clock" ] MCK , # [ doc = "RK Clock signal" ] RK , # [ doc = "TK pin" ] TK } impl CKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CKSW :: MCK => 0 , CKSW :: RK => 1 , CKSW :: TK => 2 } } } # [ doc = r" Proxy" ] pub struct _CKSW < 'a > { w : & 'a mut W , } impl < 'a > _CKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Divided Clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CKSW :: MCK ) } # [ doc = "RK Clock signal" ] # [ inline ] pub fn rk ( self ) -> & 'a mut W { self . variant ( CKSW :: RK ) } # [ doc = "TK pin" ] # [ inline ] pub fn tk ( self ) -> & 'a mut W { self . variant ( CKSW :: TK ) } # [ 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 = "Values that can be written to the field `CKO`" ] pub enum CKOW { # [ doc = "None, TK pin is an input" ] NONE , # [ doc = "Continuous Transmit Clock, TK pin is an output" ] CONTINUOUS , # [ doc = "Transmit Clock only during data transfers, TK pin is an output" ] TRANSFER } impl CKOW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CKOW :: NONE => 0 , CKOW :: CONTINUOUS => 1 , CKOW :: TRANSFER => 2 } } } # [ doc = r" Proxy" ] pub struct _CKOW < 'a > { w : & 'a mut W , } impl < 'a > _CKOW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CKOW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "None, TK pin is an input" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( CKOW :: NONE ) } # [ doc = "Continuous Transmit Clock, TK pin is an output" ] # [ inline ] pub fn continuous ( self ) -> & 'a mut W { self . variant ( CKOW :: CONTINUOUS ) } # [ doc = "Transmit Clock only during data transfers, TK pin is an output" ] # [ inline ] pub fn transfer ( self ) -> & 'a mut W { self . variant ( CKOW :: TRANSFER ) } # [ 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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CKIW < 'a > { w : & 'a mut W , } impl < 'a > _CKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `CKG`" ] pub enum CKGW { # [ doc = "None" ] CONTINUOUS , # [ doc = "Transmit Clock enabled only if TF Low" ] EN_TF_LOW , # [ doc = "Transmit Clock enabled only if TF High" ] EN_TF_HIGH } impl CKGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CKGW :: CONTINUOUS => 0 , CKGW :: EN_TF_LOW => 1 , CKGW :: EN_TF_HIGH => 2 } } } # [ doc = r" Proxy" ] pub struct _CKGW < 'a > { w : & 'a mut W , } impl < 'a > _CKGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CKGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn continuous ( self ) -> & 'a mut W { self . variant ( CKGW :: CONTINUOUS ) } # [ doc = "Transmit Clock enabled only if TF Low" ] # [ inline ] pub fn en_tf_low ( self ) -> & 'a mut W { self . variant ( CKGW :: EN_TF_LOW ) } # [ doc = "Transmit Clock enabled only if TF High" ] # [ inline ] pub fn en_tf_high ( self ) -> & 'a mut W { self . variant ( CKGW :: EN_TF_HIGH ) } # [ 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 = "Values that can be written to the field `START`" ] pub enum STARTW { # [ doc = "Continuous, as soon as a word is written in the SSC_THR Register (if Transmit is enabled), and immediately after the end of transfer of the previous data" ] CONTINUOUS , # [ doc = "Receive start" ] RECEIVE , # [ doc = "Detection of a low level on TF signal" ] TF_LOW , # [ doc = "Detection of a high level on TF signal" ] TF_HIGH , # [ doc = "Detection of a falling edge on TF signal" ] TF_FALLING , # [ doc = "Detection of a rising edge on TF signal" ] TF_RISING , # [ doc = "Detection of any level change on TF signal" ] TF_LEVEL , # [ doc = "Detection of any edge on TF signal" ] TF_EDGE } impl STARTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { STARTW :: CONTINUOUS => 0 , STARTW :: RECEIVE => 1 , STARTW :: TF_LOW => 2 , STARTW :: TF_HIGH => 3 , STARTW :: TF_FALLING => 4 , STARTW :: TF_RISING => 5 , STARTW :: TF_LEVEL => 6 , STARTW :: TF_EDGE => 7 } } } # [ doc = r" Proxy" ] pub struct _STARTW < 'a > { w : & 'a mut W , } impl < 'a > _STARTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : STARTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Continuous, as soon as a word is written in the SSC_THR Register (if Transmit is enabled), and immediately after the end of transfer of the previous data" ] # [ inline ] pub fn continuous ( self ) -> & 'a mut W { self . variant ( STARTW :: CONTINUOUS ) } # [ doc = "Receive start" ] # [ inline ] pub fn receive ( self ) -> & 'a mut W { self . variant ( STARTW :: RECEIVE ) } # [ doc = "Detection of a low level on TF signal" ] # [ inline ] pub fn tf_low ( self ) -> & 'a mut W { self . variant ( STARTW :: TF_LOW ) } # [ doc = "Detection of a high level on TF signal" ] # [ inline ] pub fn tf_high ( self ) -> & 'a mut W { self . variant ( STARTW :: TF_HIGH ) } # [ doc = "Detection of a falling edge on TF signal" ] # [ inline ] pub fn tf_falling ( self ) -> & 'a mut W { self . variant ( STARTW :: TF_FALLING ) } # [ doc = "Detection of a rising edge on TF signal" ] # [ inline ] pub fn tf_rising ( self ) -> & 'a mut W { self . variant ( STARTW :: TF_RISING ) } # [ doc = "Detection of any level change on TF signal" ] # [ inline ] pub fn tf_level ( self ) -> & 'a mut W { self . variant ( STARTW :: TF_LEVEL ) } # [ doc = "Detection of any edge on TF signal" ] # [ inline ] pub fn tf_edge ( self ) -> & 'a mut W { self . variant ( STARTW :: TF_EDGE ) } # [ 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 _STTDLYW < 'a > { w : & 'a mut W , } impl < 'a > _STTDLYW < '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 _PERIODW < 'a > { w : & 'a mut W , } impl < 'a > _PERIODW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Transmit Clock Selection" ] # [ inline ] pub fn cks ( & self ) -> CKSR { CKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 2:4 - Transmit Clock Output Mode Selection" ] # [ inline ] pub fn cko ( & self ) -> CKOR { CKOR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 5 - Transmit Clock Inversion" ] # [ inline ] pub fn cki ( & self ) -> CKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CKIR { bits } } # [ doc = "Bits 6:7 - Transmit Clock Gating Selection" ] # [ inline ] pub fn ckg ( & self ) -> CKGR { CKGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 8:11 - Transmit Start Selection" ] # [ inline ] pub fn start ( & self ) -> STARTR { STARTR :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 16:23 - Transmit Start Delay" ] # [ inline ] pub fn sttdly ( & self ) -> STTDLYR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; STTDLYR { bits } } # [ doc = "Bits 24:31 - Transmit Period Divider Selection" ] # [ inline ] pub fn period ( & self ) -> PERIODR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PERIODR { 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 - Transmit Clock Selection" ] # [ inline ] pub fn cks ( & mut self ) -> _CKSW { _CKSW { w : self } } # [ doc = "Bits 2:4 - Transmit Clock Output Mode Selection" ] # [ inline ] pub fn cko ( & mut self ) -> _CKOW { _CKOW { w : self } } # [ doc = "Bit 5 - Transmit Clock Inversion" ] # [ inline ] pub fn cki ( & mut self ) -> _CKIW { _CKIW { w : self } } # [ doc = "Bits 6:7 - Transmit Clock Gating Selection" ] # [ inline ] pub fn ckg ( & mut self ) -> _CKGW { _CKGW { w : self } } # [ doc = "Bits 8:11 - Transmit Start Selection" ] # [ inline ] pub fn start ( & mut self ) -> _STARTW { _STARTW { w : self } } # [ doc = "Bits 16:23 - Transmit Start Delay" ] # [ inline ] pub fn sttdly ( & mut self ) -> _STTDLYW { _STTDLYW { w : self } } # [ doc = "Bits 24:31 - Transmit Period Divider Selection" ] # [ inline ] pub fn period ( & mut self ) -> _PERIODW { _PERIODW { w : self } } } } # [ doc = "Transmit Frame Mode Register" ] pub struct TFMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Frame Mode Register" ] pub mod tfmr { # [ 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 :: TFMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DATDEFR { bits : bool , } impl DATDEFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MSBFR { bits : bool , } impl MSBFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DATNBR { bits : u8 , } impl DATNBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FSLENR { bits : u8 , } impl FSLENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FSOS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FSOSR { # [ doc = "None, RF pin is an input" ] NONE , # [ doc = "Negative Pulse, RF pin is an output" ] NEGATIVE , # [ doc = "Positive Pulse, RF pin is an output" ] POSITIVE , # [ doc = "Driven Low during data transfer" ] LOW , # [ doc = "Driven High during data transfer" ] HIGH , # [ doc = "Toggling at each start of data transfer" ] TOGGLING , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FSOSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FSOSR :: NONE => 0 , FSOSR :: NEGATIVE => 0x01 , FSOSR :: POSITIVE => 0x02 , FSOSR :: LOW => 0x03 , FSOSR :: HIGH => 0x04 , FSOSR :: TOGGLING => 0x05 , FSOSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FSOSR { match value { 0 => FSOSR :: NONE , 1 => FSOSR :: NEGATIVE , 2 => FSOSR :: POSITIVE , 3 => FSOSR :: LOW , 4 => FSOSR :: HIGH , 5 => FSOSR :: TOGGLING , i => FSOSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == FSOSR :: NONE } # [ doc = "Checks if the value of the field is `NEGATIVE`" ] # [ inline ] pub fn is_negative ( & self ) -> bool { * self == FSOSR :: NEGATIVE } # [ doc = "Checks if the value of the field is `POSITIVE`" ] # [ inline ] pub fn is_positive ( & self ) -> bool { * self == FSOSR :: POSITIVE } # [ doc = "Checks if the value of the field is `LOW`" ] # [ inline ] pub fn is_low ( & self ) -> bool { * self == FSOSR :: LOW } # [ doc = "Checks if the value of the field is `HIGH`" ] # [ inline ] pub fn is_high ( & self ) -> bool { * self == FSOSR :: HIGH } # [ doc = "Checks if the value of the field is `TOGGLING`" ] # [ inline ] pub fn is_toggling ( & self ) -> bool { * self == FSOSR :: TOGGLING } } # [ doc = r" Value of the field" ] pub struct FSDENR { bits : bool , } impl FSDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `FSEDGE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FSEDGER { # [ doc = "Positive Edge Detection" ] POSITIVE , # [ doc = "Negative Edge Detection" ] NEGATIVE } impl FSEDGER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { FSEDGER :: POSITIVE => false , FSEDGER :: NEGATIVE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> FSEDGER { match value { false => FSEDGER :: POSITIVE , true => FSEDGER :: NEGATIVE , } } # [ doc = "Checks if the value of the field is `POSITIVE`" ] # [ inline ] pub fn is_positive ( & self ) -> bool { * self == FSEDGER :: POSITIVE } # [ doc = "Checks if the value of the field is `NEGATIVE`" ] # [ inline ] pub fn is_negative ( & self ) -> bool { * self == FSEDGER :: NEGATIVE } } # [ doc = r" Value of the field" ] pub struct FSLEN_EXTR { bits : u8 , } impl FSLEN_EXTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 = 0x1f ; 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 _DATDEFW < 'a > { w : & 'a mut W , } impl < 'a > _DATDEFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSBFW < 'a > { w : & 'a mut W , } impl < 'a > _MSBFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DATNBW < 'a > { w : & 'a mut W , } impl < 'a > _DATNBW < '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 _FSLENW < 'a > { w : & 'a mut W , } impl < 'a > _FSLENW < '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 = "Values that can be written to the field `FSOS`" ] pub enum FSOSW { # [ doc = "None, RF pin is an input" ] NONE , # [ doc = "Negative Pulse, RF pin is an output" ] NEGATIVE , # [ doc = "Positive Pulse, RF pin is an output" ] POSITIVE , # [ doc = "Driven Low during data transfer" ] LOW , # [ doc = "Driven High during data transfer" ] HIGH , # [ doc = "Toggling at each start of data transfer" ] TOGGLING } impl FSOSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FSOSW :: NONE => 0 , FSOSW :: NEGATIVE => 1 , FSOSW :: POSITIVE => 2 , FSOSW :: LOW => 3 , FSOSW :: HIGH => 4 , FSOSW :: TOGGLING => 5 } } } # [ doc = r" Proxy" ] pub struct _FSOSW < 'a > { w : & 'a mut W , } impl < 'a > _FSOSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FSOSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "None, RF pin is an input" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( FSOSW :: NONE ) } # [ doc = "Negative Pulse, RF pin is an output" ] # [ inline ] pub fn negative ( self ) -> & 'a mut W { self . variant ( FSOSW :: NEGATIVE ) } # [ doc = "Positive Pulse, RF pin is an output" ] # [ inline ] pub fn positive ( self ) -> & 'a mut W { self . variant ( FSOSW :: POSITIVE ) } # [ doc = "Driven Low during data transfer" ] # [ inline ] pub fn low ( self ) -> & 'a mut W { self . variant ( FSOSW :: LOW ) } # [ doc = "Driven High during data transfer" ] # [ inline ] pub fn high ( self ) -> & 'a mut W { self . variant ( FSOSW :: HIGH ) } # [ doc = "Toggling at each start of data transfer" ] # [ inline ] pub fn toggling ( self ) -> & 'a mut W { self . variant ( FSOSW :: TOGGLING ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _FSDENW < 'a > { w : & 'a mut W , } impl < 'a > _FSDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FSEDGE`" ] pub enum FSEDGEW { # [ doc = "Positive Edge Detection" ] POSITIVE , # [ doc = "Negative Edge Detection" ] NEGATIVE } impl FSEDGEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { FSEDGEW :: POSITIVE => false , FSEDGEW :: NEGATIVE => true } } } # [ doc = r" Proxy" ] pub struct _FSEDGEW < 'a > { w : & 'a mut W , } impl < 'a > _FSEDGEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FSEDGEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Positive Edge Detection" ] # [ inline ] pub fn positive ( self ) -> & 'a mut W { self . variant ( FSEDGEW :: POSITIVE ) } # [ doc = "Negative Edge Detection" ] # [ inline ] pub fn negative ( self ) -> & 'a mut W { self . variant ( FSEDGEW :: NEGATIVE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSLEN_EXTW < 'a > { w : & 'a mut W , } impl < 'a > _FSLEN_EXTW < '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:4 - Data Length" ] # [ inline ] pub fn datlen ( & self ) -> DATLENR { let bits = { const MASK : u8 = 0x1f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DATLENR { bits } } # [ doc = "Bit 5 - Data Default Value" ] # [ inline ] pub fn datdef ( & self ) -> DATDEFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DATDEFR { bits } } # [ doc = "Bit 7 - Most Significant Bit First" ] # [ inline ] pub fn msbf ( & self ) -> MSBFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSBFR { bits } } # [ doc = "Bits 8:11 - Data Number per frame" ] # [ inline ] pub fn datnb ( & self ) -> DATNBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DATNBR { bits } } # [ doc = "Bits 16:19 - Transmit Frame Sync Length" ] # [ inline ] pub fn fslen ( & self ) -> FSLENR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FSLENR { bits } } # [ doc = "Bits 20:22 - Transmit Frame Sync Output Selection" ] # [ inline ] pub fn fsos ( & self ) -> FSOSR { FSOSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 23 - Frame Sync Data Enable" ] # [ inline ] pub fn fsden ( & self ) -> FSDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSDENR { bits } } # [ doc = "Bit 24 - Frame Sync Edge Detection" ] # [ inline ] pub fn fsedge ( & self ) -> FSEDGER { FSEDGER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 28:31 - FSLEN Field Extension" ] # [ inline ] pub fn fslen_ext ( & self ) -> FSLEN_EXTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FSLEN_EXTR { 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:4 - Data Length" ] # [ inline ] pub fn datlen ( & mut self ) -> _DATLENW { _DATLENW { w : self } } # [ doc = "Bit 5 - Data Default Value" ] # [ inline ] pub fn datdef ( & mut self ) -> _DATDEFW { _DATDEFW { w : self } } # [ doc = "Bit 7 - Most Significant Bit First" ] # [ inline ] pub fn msbf ( & mut self ) -> _MSBFW { _MSBFW { w : self } } # [ doc = "Bits 8:11 - Data Number per frame" ] # [ inline ] pub fn datnb ( & mut self ) -> _DATNBW { _DATNBW { w : self } } # [ doc = "Bits 16:19 - Transmit Frame Sync Length" ] # [ inline ] pub fn fslen ( & mut self ) -> _FSLENW { _FSLENW { w : self } } # [ doc = "Bits 20:22 - Transmit Frame Sync Output Selection" ] # [ inline ] pub fn fsos ( & mut self ) -> _FSOSW { _FSOSW { w : self } } # [ doc = "Bit 23 - Frame Sync Data Enable" ] # [ inline ] pub fn fsden ( & mut self ) -> _FSDENW { _FSDENW { w : self } } # [ doc = "Bit 24 - Frame Sync Edge Detection" ] # [ inline ] pub fn fsedge ( & mut self ) -> _FSEDGEW { _FSEDGEW { w : self } } # [ doc = "Bits 28:31 - FSLEN Field Extension" ] # [ inline ] pub fn fslen_ext ( & mut self ) -> _FSLEN_EXTW { _FSLEN_EXTW { w : self } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 RDATR { bits : u32 , } impl RDATR { # [ 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 - Receive Data" ] # [ inline ] pub fn rdat ( & self ) -> RDATR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RDATR { bits } } } } # [ doc = "Transmit Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TDATW < 'a > { w : & 'a mut W , } impl < 'a > _TDATW < '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 = "Bits 0:31 - Transmit Data" ] # [ inline ] pub fn tdat ( & mut self ) -> _TDATW { _TDATW { w : self } } } } # [ doc = "Receive Sync. Holding Register" ] pub struct RSHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Sync. Holding Register" ] pub mod rshr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RSHR { # [ 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 RSDATR { bits : u16 , } impl RSDATR { # [ 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 - Receive Synchronization Data" ] # [ inline ] pub fn rsdat ( & self ) -> RSDATR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RSDATR { bits } } } } # [ doc = "Transmit Sync. Holding Register" ] pub struct TSHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Sync. Holding Register" ] pub mod tshr { # [ 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 :: TSHR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TSDATR { bits : u16 , } impl TSDATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TSDATW < 'a > { w : & 'a mut W , } impl < 'a > _TSDATW < '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 - Transmit Synchronization Data" ] # [ inline ] pub fn tsdat ( & self ) -> TSDATR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TSDATR { 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 - Transmit Synchronization Data" ] # [ inline ] pub fn tsdat ( & mut self ) -> _TSDATW { _TSDATW { w : self } } } } # [ doc = "Receive Compare 0 Register" ] pub struct RC0R { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Compare 0 Register" ] pub mod rc0r { # [ 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 :: RC0R { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CP0R { bits : u16 , } impl CP0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CP0W < 'a > { w : & 'a mut W , } impl < 'a > _CP0W < '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 - Receive Compare Data 0" ] # [ inline ] pub fn cp0 ( & self ) -> CP0R { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; CP0R { 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 - Receive Compare Data 0" ] # [ inline ] pub fn cp0 ( & mut self ) -> _CP0W { _CP0W { w : self } } } } # [ doc = "Receive Compare 1 Register" ] pub struct RC1R { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Compare 1 Register" ] pub mod rc1r { # [ 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 :: RC1R { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CP1R { bits : u16 , } impl CP1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CP1W < 'a > { w : & 'a mut W , } impl < 'a > _CP1W < '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 - Receive Compare Data 1" ] # [ inline ] pub fn cp1 ( & self ) -> CP1R { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; CP1R { 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 - Receive Compare Data 1" ] # [ inline ] pub fn cp1 ( & mut self ) -> _CP1W { _CP1W { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRUNR { bits : bool , } impl OVRUNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CP0R { bits : bool , } impl CP0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CP1R { bits : bool , } impl CP1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXSYNR { bits : bool , } impl TXSYNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSYNR { bits : bool , } impl RXSYNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXENR { bits : bool , } impl TXENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXENR { bits : bool , } impl RXENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmit Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 1 - Transmit Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 4 - Receive Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 5 - Receive Overrun" ] # [ inline ] pub fn ovrun ( & self ) -> OVRUNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRUNR { bits } } # [ doc = "Bit 8 - Compare 0" ] # [ inline ] pub fn cp0 ( & self ) -> CP0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CP0R { bits } } # [ doc = "Bit 9 - Compare 1" ] # [ inline ] pub fn cp1 ( & self ) -> CP1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CP1R { bits } } # [ doc = "Bit 10 - Transmit Sync" ] # [ inline ] pub fn txsyn ( & self ) -> TXSYNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXSYNR { bits } } # [ doc = "Bit 11 - Receive Sync" ] # [ inline ] pub fn rxsyn ( & self ) -> RXSYNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSYNR { bits } } # [ doc = "Bit 16 - Transmit Enable" ] # [ inline ] pub fn txen ( & self ) -> TXENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXENR { bits } } # [ doc = "Bit 17 - Receive Enable" ] # [ inline ] pub fn rxen ( & self ) -> RXENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXENR { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVRUNW < 'a > { w : & 'a mut W , } impl < 'a > _OVRUNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CP0W < 'a > { w : & 'a mut W , } impl < 'a > _CP0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CP1W < 'a > { w : & 'a mut W , } impl < 'a > _CP1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXSYNW < 'a > { w : & 'a mut W , } impl < 'a > _TXSYNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSYNW < 'a > { w : & 'a mut W , } impl < 'a > _RXSYNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Transmit Ready Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 1 - Transmit Empty Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 4 - Receive Ready Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 5 - Receive Overrun Interrupt Enable" ] # [ inline ] pub fn ovrun ( & mut self ) -> _OVRUNW { _OVRUNW { w : self } } # [ doc = "Bit 8 - Compare 0 Interrupt Enable" ] # [ inline ] pub fn cp0 ( & mut self ) -> _CP0W { _CP0W { w : self } } # [ doc = "Bit 9 - Compare 1 Interrupt Enable" ] # [ inline ] pub fn cp1 ( & mut self ) -> _CP1W { _CP1W { w : self } } # [ doc = "Bit 10 - Tx Sync Interrupt Enable" ] # [ inline ] pub fn txsyn ( & mut self ) -> _TXSYNW { _TXSYNW { w : self } } # [ doc = "Bit 11 - Rx Sync Interrupt Enable" ] # [ inline ] pub fn rxsyn ( & mut self ) -> _RXSYNW { _RXSYNW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVRUNW < 'a > { w : & 'a mut W , } impl < 'a > _OVRUNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CP0W < 'a > { w : & 'a mut W , } impl < 'a > _CP0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CP1W < 'a > { w : & 'a mut W , } impl < 'a > _CP1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXSYNW < 'a > { w : & 'a mut W , } impl < 'a > _TXSYNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSYNW < 'a > { w : & 'a mut W , } impl < 'a > _RXSYNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Transmit Ready Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 1 - Transmit Empty Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 4 - Receive Ready Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 5 - Receive Overrun Interrupt Disable" ] # [ inline ] pub fn ovrun ( & mut self ) -> _OVRUNW { _OVRUNW { w : self } } # [ doc = "Bit 8 - Compare 0 Interrupt Disable" ] # [ inline ] pub fn cp0 ( & mut self ) -> _CP0W { _CP0W { w : self } } # [ doc = "Bit 9 - Compare 1 Interrupt Disable" ] # [ inline ] pub fn cp1 ( & mut self ) -> _CP1W { _CP1W { w : self } } # [ doc = "Bit 10 - Tx Sync Interrupt Enable" ] # [ inline ] pub fn txsyn ( & mut self ) -> _TXSYNW { _TXSYNW { w : self } } # [ doc = "Bit 11 - Rx Sync Interrupt Enable" ] # [ inline ] pub fn rxsyn ( & mut self ) -> _RXSYNW { _RXSYNW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRUNR { bits : bool , } impl OVRUNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CP0R { bits : bool , } impl CP0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CP1R { bits : bool , } impl CP1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXSYNR { bits : bool , } impl TXSYNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSYNR { bits : bool , } impl RXSYNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmit Ready Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 1 - Transmit Empty Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 4 - Receive Ready Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 5 - Receive Overrun Interrupt Mask" ] # [ inline ] pub fn ovrun ( & self ) -> OVRUNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRUNR { bits } } # [ doc = "Bit 8 - Compare 0 Interrupt Mask" ] # [ inline ] pub fn cp0 ( & self ) -> CP0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CP0R { bits } } # [ doc = "Bit 9 - Compare 1 Interrupt Mask" ] # [ inline ] pub fn cp1 ( & self ) -> CP1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CP1R { bits } } # [ doc = "Bit 10 - Tx Sync Interrupt Mask" ] # [ inline ] pub fn txsyn ( & self ) -> TXSYNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXSYNR { bits } } # [ doc = "Bit 11 - Rx Sync Interrupt Mask" ] # [ inline ] pub fn rxsyn ( & self ) -> RXSYNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSYNR { bits } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0053_5343 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5460803 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5460803 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ doc = r" Reads the contents of the register" ] # [ inline ] pub fn read ( & self ) -> R { R { bits : self . register . get ( ) } } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } } } # [ doc = "Serial Peripheral Interface 0" ] pub struct SPI0 { _marker : PhantomData < * const ( ) > } unsafe impl Send for SPI0 { } impl SPI0 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const spi0 :: RegisterBlock { 0x4000_8000 as * const _ } } impl Deref for SPI0 { type Target = spi0 :: RegisterBlock ; fn deref ( & self ) -> & spi0 :: RegisterBlock { unsafe { & * SPI0 :: ptr ( ) } } } # [ doc = "Serial Peripheral Interface 0" ] pub mod spi0 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Mode Register" ] pub mr : MR , # [ doc = "0x08 - Receive Data Register" ] pub rdr : RDR , # [ doc = "0x0c - Transmit Data Register" ] pub tdr : TDR , # [ doc = "0x10 - Status Register" ] pub sr : SR , # [ doc = "0x14 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x18 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x1c - Interrupt Mask Register" ] pub imr : IMR , _reserved8 : [ u8 ; 16usize ] , # [ doc = "0x30 - Chip Select Register" ] pub csr : [ CSR ; 4 ] , _reserved9 : [ u8 ; 164usize ] , # [ doc = "0xe4 - Write Protection Control Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protection Status Register" ] pub wpsr : WPSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SPIENW < 'a > { w : & 'a mut W , } impl < 'a > _SPIENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SPIDISW < 'a > { w : & 'a mut W , } impl < 'a > _SPIDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 7 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _LASTXFERW < 'a > { w : & 'a mut W , } impl < 'a > _LASTXFERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - SPI Enable" ] # [ inline ] pub fn spien ( & mut self ) -> _SPIENW { _SPIENW { w : self } } # [ doc = "Bit 1 - SPI Disable" ] # [ inline ] pub fn spidis ( & mut self ) -> _SPIDISW { _SPIDISW { w : self } } # [ doc = "Bit 7 - SPI Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } # [ doc = "Bit 24 - Last Transfer" ] # [ inline ] pub fn lastxfer ( & mut self ) -> _LASTXFERW { _LASTXFERW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 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 PCSDECR { bits : bool , } impl PCSDECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODFDISR { bits : bool , } impl MODFDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WDRBTR { bits : bool , } impl WDRBTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LLBR { bits : bool , } impl LLBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCSR { bits : u8 , } impl PCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DLYBCSR { bits : u8 , } impl DLYBCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 = 0 ; 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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _PCSDECW < 'a > { w : & 'a mut W , } impl < 'a > _PCSDECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODFDISW < 'a > { w : & 'a mut W , } impl < 'a > _MODFDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WDRBTW < 'a > { w : & 'a mut W , } impl < 'a > _WDRBTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LLBW < 'a > { w : & 'a mut W , } impl < 'a > _LLBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCSW < 'a > { w : & 'a mut W , } impl < 'a > _PCSW < '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 _DLYBCSW < 'a > { w : & 'a mut W , } impl < 'a > _DLYBCSW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Master/Slave Mode" ] # [ inline ] pub fn mstr ( & self ) -> MSTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSTRR { bits } } # [ doc = "Bit 1 - Peripheral Select" ] # [ inline ] pub fn ps ( & self ) -> PSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PSR { bits } } # [ doc = "Bit 2 - Chip Select Decode" ] # [ inline ] pub fn pcsdec ( & self ) -> PCSDECR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCSDECR { bits } } # [ doc = "Bit 4 - Mode Fault Detection" ] # [ inline ] pub fn modfdis ( & self ) -> MODFDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODFDISR { bits } } # [ doc = "Bit 5 - Wait Data Read Before Transfer" ] # [ inline ] pub fn wdrbt ( & self ) -> WDRBTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDRBTR { bits } } # [ doc = "Bit 7 - Local Loopback Enable" ] # [ inline ] pub fn llb ( & self ) -> LLBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LLBR { bits } } # [ doc = "Bits 16:19 - Peripheral Chip Select" ] # [ inline ] pub fn pcs ( & self ) -> PCSR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PCSR { bits } } # [ doc = "Bits 24:31 - Delay Between Chip Selects" ] # [ inline ] pub fn dlybcs ( & self ) -> DLYBCSR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DLYBCSR { 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 - Master/Slave Mode" ] # [ inline ] pub fn mstr ( & mut self ) -> _MSTRW { _MSTRW { w : self } } # [ doc = "Bit 1 - Peripheral Select" ] # [ inline ] pub fn ps ( & mut self ) -> _PSW { _PSW { w : self } } # [ doc = "Bit 2 - Chip Select Decode" ] # [ inline ] pub fn pcsdec ( & mut self ) -> _PCSDECW { _PCSDECW { w : self } } # [ doc = "Bit 4 - Mode Fault Detection" ] # [ inline ] pub fn modfdis ( & mut self ) -> _MODFDISW { _MODFDISW { w : self } } # [ doc = "Bit 5 - Wait Data Read Before Transfer" ] # [ inline ] pub fn wdrbt ( & mut self ) -> _WDRBTW { _WDRBTW { w : self } } # [ doc = "Bit 7 - Local Loopback Enable" ] # [ inline ] pub fn llb ( & mut self ) -> _LLBW { _LLBW { w : self } } # [ doc = "Bits 16:19 - Peripheral Chip Select" ] # [ inline ] pub fn pcs ( & mut self ) -> _PCSW { _PCSW { w : self } } # [ doc = "Bits 24:31 - Delay Between Chip Selects" ] # [ inline ] pub fn dlybcs ( & mut self ) -> _DLYBCSW { _DLYBCSW { w : self } } } } # [ doc = "Receive Data Register" ] pub struct RDR { register : :: vcell :: VolatileCell < u32 > } # [ 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 RDR { bits : u16 , } impl RDR { # [ 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 PCSR { bits : u8 , } impl PCSR { # [ 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:15 - Receive Data" ] # [ inline ] pub fn rd ( & self ) -> RDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RDR { bits } } # [ doc = "Bits 16:19 - Peripheral Chip Select" ] # [ inline ] pub fn pcs ( & self ) -> PCSR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PCSR { bits } } } } # [ doc = "Transmit Data Register" ] pub struct TDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Data Register" ] pub mod tdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: TDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TDW < 'a > { w : & 'a mut W , } impl < 'a > _TDW < '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 } } # [ doc = r" Proxy" ] pub struct _PCSW < 'a > { w : & 'a mut W , } impl < 'a > _PCSW < '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 _LASTXFERW < 'a > { w : & 'a mut W , } impl < 'a > _LASTXFERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:15 - Transmit Data" ] # [ inline ] pub fn td ( & mut self ) -> _TDW { _TDW { w : self } } # [ doc = "Bits 16:19 - Peripheral Chip Select" ] # [ inline ] pub fn pcs ( & mut self ) -> _PCSW { _PCSW { w : self } } # [ doc = "Bit 24 - Last Transfer" ] # [ inline ] pub fn lastxfer ( & mut self ) -> _LASTXFERW { _LASTXFERW { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 RDRFR { bits : bool , } impl RDRFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TDRER { bits : bool , } impl TDRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 OVRESR { bits : bool , } impl OVRESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NSSRR { bits : bool , } impl NSSRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDESR { bits : bool , } impl UNDESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SPIENSR { bits : bool , } impl SPIENSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receive Data Register Full" ] # [ inline ] pub fn rdrf ( & self ) -> RDRFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RDRFR { bits } } # [ doc = "Bit 1 - Transmit Data Register Empty" ] # [ inline ] pub fn tdre ( & self ) -> TDRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDRER { bits } } # [ doc = "Bit 2 - Mode Fault Error" ] # [ inline ] pub fn modf ( & self ) -> MODFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODFR { bits } } # [ doc = "Bit 3 - Overrun Error Status" ] # [ inline ] pub fn ovres ( & self ) -> OVRESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRESR { bits } } # [ doc = "Bit 8 - NSS Rising" ] # [ inline ] pub fn nssr ( & self ) -> NSSRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NSSRR { bits } } # [ doc = "Bit 9 - Transmission Registers Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Underrun Error Status (Slave Mode Only)" ] # [ inline ] pub fn undes ( & self ) -> UNDESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDESR { bits } } # [ doc = "Bit 16 - SPI Enable Status" ] # [ inline ] pub fn spiens ( & self ) -> SPIENSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SPIENSR { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RDRFW < 'a > { w : & 'a mut W , } impl < 'a > _RDRFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDREW < 'a > { w : & 'a mut W , } impl < 'a > _TDREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODFW < 'a > { w : & 'a mut W , } impl < 'a > _MODFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVRESW < 'a > { w : & 'a mut W , } impl < 'a > _OVRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NSSRW < 'a > { w : & 'a mut W , } impl < 'a > _NSSRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDESW < 'a > { w : & 'a mut W , } impl < 'a > _UNDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Receive Data Register Full Interrupt Enable" ] # [ inline ] pub fn rdrf ( & mut self ) -> _RDRFW { _RDRFW { w : self } } # [ doc = "Bit 1 - SPI Transmit Data Register Empty Interrupt Enable" ] # [ inline ] pub fn tdre ( & mut self ) -> _TDREW { _TDREW { w : self } } # [ doc = "Bit 2 - Mode Fault Error Interrupt Enable" ] # [ inline ] pub fn modf ( & mut self ) -> _MODFW { _MODFW { w : self } } # [ doc = "Bit 3 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovres ( & mut self ) -> _OVRESW { _OVRESW { w : self } } # [ doc = "Bit 8 - NSS Rising Interrupt Enable" ] # [ inline ] pub fn nssr ( & mut self ) -> _NSSRW { _NSSRW { w : self } } # [ doc = "Bit 9 - Transmission Registers Empty Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Underrun Error Interrupt Enable" ] # [ inline ] pub fn undes ( & mut self ) -> _UNDESW { _UNDESW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RDRFW < 'a > { w : & 'a mut W , } impl < 'a > _RDRFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDREW < 'a > { w : & 'a mut W , } impl < 'a > _TDREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODFW < 'a > { w : & 'a mut W , } impl < 'a > _MODFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVRESW < 'a > { w : & 'a mut W , } impl < 'a > _OVRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NSSRW < 'a > { w : & 'a mut W , } impl < 'a > _NSSRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDESW < 'a > { w : & 'a mut W , } impl < 'a > _UNDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Receive Data Register Full Interrupt Disable" ] # [ inline ] pub fn rdrf ( & mut self ) -> _RDRFW { _RDRFW { w : self } } # [ doc = "Bit 1 - SPI Transmit Data Register Empty Interrupt Disable" ] # [ inline ] pub fn tdre ( & mut self ) -> _TDREW { _TDREW { w : self } } # [ doc = "Bit 2 - Mode Fault Error Interrupt Disable" ] # [ inline ] pub fn modf ( & mut self ) -> _MODFW { _MODFW { w : self } } # [ doc = "Bit 3 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovres ( & mut self ) -> _OVRESW { _OVRESW { w : self } } # [ doc = "Bit 8 - NSS Rising Interrupt Disable" ] # [ inline ] pub fn nssr ( & mut self ) -> _NSSRW { _NSSRW { w : self } } # [ doc = "Bit 9 - Transmission Registers Empty Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Underrun Error Interrupt Disable" ] # [ inline ] pub fn undes ( & mut self ) -> _UNDESW { _UNDESW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 RDRFR { bits : bool , } impl RDRFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TDRER { bits : bool , } impl TDRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 OVRESR { bits : bool , } impl OVRESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NSSRR { bits : bool , } impl NSSRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDESR { bits : bool , } impl UNDESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receive Data Register Full Interrupt Mask" ] # [ inline ] pub fn rdrf ( & self ) -> RDRFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RDRFR { bits } } # [ doc = "Bit 1 - SPI Transmit Data Register Empty Interrupt Mask" ] # [ inline ] pub fn tdre ( & self ) -> TDRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDRER { bits } } # [ doc = "Bit 2 - Mode Fault Error Interrupt Mask" ] # [ inline ] pub fn modf ( & self ) -> MODFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODFR { bits } } # [ doc = "Bit 3 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovres ( & self ) -> OVRESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRESR { bits } } # [ doc = "Bit 8 - NSS Rising Interrupt Mask" ] # [ inline ] pub fn nssr ( & self ) -> NSSRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NSSRR { bits } } # [ doc = "Bit 9 - Transmission Registers Empty Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Underrun Error Interrupt Mask" ] # [ inline ] pub fn undes ( & self ) -> UNDESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDESR { bits } } } } # [ doc = "Chip Select Register" ] pub struct CSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Chip Select 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 < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 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 NCPHAR { bits : bool , } impl NCPHAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSNAATR { bits : bool , } impl CSNAATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSAATR { bits : bool , } impl CSAATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BITS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BITSR { # [ doc = "8 bits for transfer" ] _8_BIT , # [ doc = "9 bits for transfer" ] _9_BIT , # [ doc = "10 bits for transfer" ] _10_BIT , # [ doc = "11 bits for transfer" ] _11_BIT , # [ doc = "12 bits for transfer" ] _12_BIT , # [ doc = "13 bits for transfer" ] _13_BIT , # [ doc = "14 bits for transfer" ] _14_BIT , # [ doc = "15 bits for transfer" ] _15_BIT , # [ doc = "16 bits for transfer" ] _16_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl BITSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BITSR :: _8_BIT => 0 , BITSR :: _9_BIT => 0x01 , BITSR :: _10_BIT => 0x02 , BITSR :: _11_BIT => 0x03 , BITSR :: _12_BIT => 0x04 , BITSR :: _13_BIT => 0x05 , BITSR :: _14_BIT => 0x06 , BITSR :: _15_BIT => 0x07 , BITSR :: _16_BIT => 0x08 , BITSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BITSR { match value { 0 => BITSR :: _8_BIT , 1 => BITSR :: _9_BIT , 2 => BITSR :: _10_BIT , 3 => BITSR :: _11_BIT , 4 => BITSR :: _12_BIT , 5 => BITSR :: _13_BIT , 6 => BITSR :: _14_BIT , 7 => BITSR :: _15_BIT , 8 => BITSR :: _16_BIT , i => BITSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == BITSR :: _8_BIT } # [ doc = "Checks if the value of the field is `_9_BIT`" ] # [ inline ] pub fn is_9_bit ( & self ) -> bool { * self == BITSR :: _9_BIT } # [ doc = "Checks if the value of the field is `_10_BIT`" ] # [ inline ] pub fn is_10_bit ( & self ) -> bool { * self == BITSR :: _10_BIT } # [ doc = "Checks if the value of the field is `_11_BIT`" ] # [ inline ] pub fn is_11_bit ( & self ) -> bool { * self == BITSR :: _11_BIT } # [ doc = "Checks if the value of the field is `_12_BIT`" ] # [ inline ] pub fn is_12_bit ( & self ) -> bool { * self == BITSR :: _12_BIT } # [ doc = "Checks if the value of the field is `_13_BIT`" ] # [ inline ] pub fn is_13_bit ( & self ) -> bool { * self == BITSR :: _13_BIT } # [ doc = "Checks if the value of the field is `_14_BIT`" ] # [ inline ] pub fn is_14_bit ( & self ) -> bool { * self == BITSR :: _14_BIT } # [ doc = "Checks if the value of the field is `_15_BIT`" ] # [ inline ] pub fn is_15_bit ( & self ) -> bool { * self == BITSR :: _15_BIT } # [ doc = "Checks if the value of the field is `_16_BIT`" ] # [ inline ] pub fn is_16_bit ( & self ) -> bool { * self == BITSR :: _16_BIT } } # [ doc = r" Value of the field" ] pub struct SCBRR { bits : u8 , } impl SCBRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DLYBSR { bits : u8 , } impl DLYBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DLYBCTR { bits : u8 , } impl DLYBCTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NCPHAW < 'a > { w : & 'a mut W , } impl < 'a > _NCPHAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSNAATW < 'a > { w : & 'a mut W , } impl < 'a > _CSNAATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSAATW < 'a > { w : & 'a mut W , } impl < 'a > _CSAATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BITS`" ] pub enum BITSW { # [ doc = "8 bits for transfer" ] _8_BIT , # [ doc = "9 bits for transfer" ] _9_BIT , # [ doc = "10 bits for transfer" ] _10_BIT , # [ doc = "11 bits for transfer" ] _11_BIT , # [ doc = "12 bits for transfer" ] _12_BIT , # [ doc = "13 bits for transfer" ] _13_BIT , # [ doc = "14 bits for transfer" ] _14_BIT , # [ doc = "15 bits for transfer" ] _15_BIT , # [ doc = "16 bits for transfer" ] _16_BIT } impl BITSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BITSW :: _8_BIT => 0 , BITSW :: _9_BIT => 1 , BITSW :: _10_BIT => 2 , BITSW :: _11_BIT => 3 , BITSW :: _12_BIT => 4 , BITSW :: _13_BIT => 5 , BITSW :: _14_BIT => 6 , BITSW :: _15_BIT => 7 , BITSW :: _16_BIT => 8 } } } # [ doc = r" Proxy" ] pub struct _BITSW < 'a > { w : & 'a mut W , } impl < 'a > _BITSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BITSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "8 bits for transfer" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _8_BIT ) } # [ doc = "9 bits for transfer" ] # [ inline ] pub fn _9_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _9_BIT ) } # [ doc = "10 bits for transfer" ] # [ inline ] pub fn _10_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _10_BIT ) } # [ doc = "11 bits for transfer" ] # [ inline ] pub fn _11_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _11_BIT ) } # [ doc = "12 bits for transfer" ] # [ inline ] pub fn _12_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _12_BIT ) } # [ doc = "13 bits for transfer" ] # [ inline ] pub fn _13_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _13_BIT ) } # [ doc = "14 bits for transfer" ] # [ inline ] pub fn _14_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _14_BIT ) } # [ doc = "15 bits for transfer" ] # [ inline ] pub fn _15_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _15_BIT ) } # [ doc = "16 bits for transfer" ] # [ inline ] pub fn _16_bit ( self ) -> & 'a mut W { self . variant ( BITSW :: _16_BIT ) } # [ 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 _SCBRW < 'a > { w : & 'a mut W , } impl < 'a > _SCBRW < '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 _DLYBSW < 'a > { w : & 'a mut W , } impl < 'a > _DLYBSW < '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 _DLYBCTW < 'a > { w : & 'a mut W , } impl < 'a > _DLYBCTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Clock Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 1 - Clock Phase" ] # [ inline ] pub fn ncpha ( & self ) -> NCPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NCPHAR { bits } } # [ doc = "Bit 2 - Chip Select Not Active After Transfer (Ignored if CSAAT = 1)" ] # [ inline ] pub fn csnaat ( & self ) -> CSNAATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSNAATR { bits } } # [ doc = "Bit 3 - Chip Select Active After Transfer" ] # [ inline ] pub fn csaat ( & self ) -> CSAATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSAATR { bits } } # [ doc = "Bits 4:7 - Bits Per Transfer" ] # [ inline ] pub fn bits_ ( & self ) -> BITSR { BITSR :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 8:15 - Serial Clock Baud Rate" ] # [ inline ] pub fn scbr ( & self ) -> SCBRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SCBRR { bits } } # [ doc = "Bits 16:23 - Delay Before SPCK" ] # [ inline ] pub fn dlybs ( & self ) -> DLYBSR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DLYBSR { bits } } # [ doc = "Bits 24:31 - Delay Between Consecutive Transfers" ] # [ inline ] pub fn dlybct ( & self ) -> DLYBCTR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DLYBCTR { bits } } } impl W { # [ doc = "Bit 0 - Clock Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 1 - Clock Phase" ] # [ inline ] pub fn ncpha ( & mut self ) -> _NCPHAW { _NCPHAW { w : self } } # [ doc = "Bit 2 - Chip Select Not Active After Transfer (Ignored if CSAAT = 1)" ] # [ inline ] pub fn csnaat ( & mut self ) -> _CSNAATW { _CSNAATW { w : self } } # [ doc = "Bit 3 - Chip Select Active After Transfer" ] # [ inline ] pub fn csaat ( & mut self ) -> _CSAATW { _CSAATW { w : self } } # [ doc = "Bits 4:7 - Bits Per Transfer" ] # [ inline ] pub fn bits_ ( & mut self ) -> _BITSW { _BITSW { w : self } } # [ doc = "Bits 8:15 - Serial Clock Baud Rate" ] # [ inline ] pub fn scbr ( & mut self ) -> _SCBRW { _SCBRW { w : self } } # [ doc = "Bits 16:23 - Delay Before SPCK" ] # [ inline ] pub fn dlybs ( & mut self ) -> _DLYBSW { _DLYBSW { w : self } } # [ doc = "Bits 24:31 - Delay Between Consecutive Transfers" ] # [ inline ] pub fn dlybct ( & mut self ) -> _DLYBCTW { _DLYBCTW { w : self } } } } # [ doc = "Write Protection Control Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Control Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0053_5049 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5460041 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5460041 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect Key" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect Key" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protection Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u8 , } impl WPVSRCR { # [ 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 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:15 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WPVSRCR { bits } } } } } # [ doc = "Timer Counter 0" ] pub struct TC0 { _marker : PhantomData < * const ( ) > } unsafe impl Send for TC0 { } impl TC0 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const tc0 :: RegisterBlock { 0x4008_0000 as * const _ } } impl Deref for TC0 { type Target = tc0 :: RegisterBlock ; fn deref ( & self ) -> & tc0 :: RegisterBlock { unsafe { & * TC0 :: ptr ( ) } } } # [ doc = "Timer Counter 0" ] pub mod tc0 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Channel Control Register (channel = 0)" ] pub ccr0 : CCR0 , # [ doc = "Channel Mode Register (channel = 0)" ] pub cmr0 : CMR0_UNION , # [ doc = "0x08 - Stepper Motor Mode Register (channel = 0)" ] pub smmr0 : SMMR0 , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Counter Value (channel = 0)" ] pub cv0 : CV0 , # [ doc = "0x14 - Register A (channel = 0)" ] pub ra0 : RA0 , # [ doc = "0x18 - Register B (channel = 0)" ] pub rb0 : RB0 , # [ doc = "0x1c - Register C (channel = 0)" ] pub rc0 : RC0 , # [ doc = "0x20 - Status Register (channel = 0)" ] pub sr0 : SR0 , # [ doc = "0x24 - Interrupt Enable Register (channel = 0)" ] pub ier0 : IER0 , # [ doc = "0x28 - Interrupt Disable Register (channel = 0)" ] pub idr0 : IDR0 , # [ doc = "0x2c - Interrupt Mask Register (channel = 0)" ] pub imr0 : IMR0 , _reserved11 : [ u8 ; 16usize ] , # [ doc = "0x40 - Channel Control Register (channel = 1)" ] pub ccr1 : CCR1 , # [ doc = "Channel Mode Register (channel = 1)" ] pub cmr1 : CMR1_UNION , # [ doc = "0x48 - Stepper Motor Mode Register (channel = 1)" ] pub smmr1 : SMMR1 , _reserved14 : [ u8 ; 4usize ] , # [ doc = "0x50 - Counter Value (channel = 1)" ] pub cv1 : CV1 , # [ doc = "0x54 - Register A (channel = 1)" ] pub ra1 : RA1 , # [ doc = "0x58 - Register B (channel = 1)" ] pub rb1 : RB1 , # [ doc = "0x5c - Register C (channel = 1)" ] pub rc1 : RC1 , # [ doc = "0x60 - Status Register (channel = 1)" ] pub sr1 : SR1 , # [ doc = "0x64 - Interrupt Enable Register (channel = 1)" ] pub ier1 : IER1 , # [ doc = "0x68 - Interrupt Disable Register (channel = 1)" ] pub idr1 : IDR1 , # [ doc = "0x6c - Interrupt Mask Register (channel = 1)" ] pub imr1 : IMR1 , _reserved22 : [ u8 ; 16usize ] , # [ doc = "0x80 - Channel Control Register (channel = 2)" ] pub ccr2 : CCR2 , # [ doc = "Channel Mode Register (channel = 2)" ] pub cmr2 : CMR2_UNION , # [ doc = "0x88 - Stepper Motor Mode Register (channel = 2)" ] pub smmr2 : SMMR2 , _reserved25 : [ u8 ; 4usize ] , # [ doc = "0x90 - Counter Value (channel = 2)" ] pub cv2 : CV2 , # [ doc = "0x94 - Register A (channel = 2)" ] pub ra2 : RA2 , # [ doc = "0x98 - Register B (channel = 2)" ] pub rb2 : RB2 , # [ doc = "0x9c - Register C (channel = 2)" ] pub rc2 : RC2 , # [ doc = "0xa0 - Status Register (channel = 2)" ] pub sr2 : SR2 , # [ doc = "0xa4 - Interrupt Enable Register (channel = 2)" ] pub ier2 : IER2 , # [ doc = "0xa8 - Interrupt Disable Register (channel = 2)" ] pub idr2 : IDR2 , # [ doc = "0xac - Interrupt Mask Register (channel = 2)" ] pub imr2 : IMR2 , _reserved33 : [ u8 ; 16usize ] , # [ doc = "0xc0 - Block Control Register" ] pub bcr : BCR , # [ doc = "0xc4 - Block Mode Register" ] pub bmr : BMR , # [ doc = "0xc8 - QDEC Interrupt Enable Register" ] pub qier : QIER , # [ doc = "0xcc - QDEC Interrupt Disable Register" ] pub qidr : QIDR , # [ doc = "0xd0 - QDEC Interrupt Mask Register" ] pub qimr : QIMR , # [ doc = "0xd4 - QDEC Interrupt Status Register" ] pub qisr : QISR , # [ doc = "0xd8 - Fault Mode Register" ] pub fmr : FMR , _reserved40 : [ u8 ; 8usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , } # [ doc = "Channel Mode Register (channel = 0)" ] # [ repr ( C ) ] pub union CMR0_UNION { # [ doc = "0x04 - Channel Mode Register (channel = 0)" ] pub cmr0_wave_eq_1 : CMR0_WAVE_EQ_1 , # [ doc = "0x04 - Channel Mode Register (channel = 0)" ] pub cmr0 : CMR0 , } # [ doc = "Channel Mode Register (channel = 1)" ] # [ repr ( C ) ] pub union CMR1_UNION { # [ doc = "0x44 - Channel Mode Register (channel = 1)" ] pub cmr1_wave_eq_1 : CMR1_WAVE_EQ_1 , # [ doc = "0x44 - Channel Mode Register (channel = 1)" ] pub cmr1 : CMR1 , } # [ doc = "Channel Mode Register (channel = 2)" ] # [ repr ( C ) ] pub union CMR2_UNION { # [ doc = "0x84 - Channel Mode Register (channel = 2)" ] pub cmr2_wave_eq_1 : CMR2_WAVE_EQ_1 , # [ doc = "0x84 - Channel Mode Register (channel = 2)" ] pub cmr2 : CMR2 , } # [ doc = "Channel Control Register (channel = 0)" ] pub struct CCR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 0)" ] pub mod ccr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 0)" ] pub struct CMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 0)" ] pub mod cmr0 { # [ 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 :: CMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 0)" ] pub struct CMR0_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 0)" ] pub mod cmr0_wave_eq_1 { # [ 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 :: CMR0_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 0)" ] pub struct SMMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 0)" ] pub mod smmr0 { # [ 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 :: SMMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 0)" ] pub struct CV0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 0)" ] pub mod cv0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV0 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 0)" ] pub struct RA0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 0)" ] pub mod ra0 { # [ 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 :: RA0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 0)" ] pub struct RB0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 0)" ] pub mod rb0 { # [ 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 :: RB0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 0)" ] pub struct RC0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 0)" ] pub mod rc0 { # [ 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 :: RC0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 0)" ] pub struct SR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 0)" ] pub mod sr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR0 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 0)" ] pub struct IER0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 0)" ] pub mod ier0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 0)" ] pub struct IDR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 0)" ] pub mod idr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 0)" ] pub struct IMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 0)" ] pub mod imr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR0 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Channel Control Register (channel = 1)" ] pub struct CCR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 1)" ] pub mod ccr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 1)" ] pub struct CMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 1)" ] pub mod cmr1 { # [ 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 :: CMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 1)" ] pub struct CMR1_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 1)" ] pub mod cmr1_wave_eq_1 { # [ 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 :: CMR1_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 1)" ] pub struct SMMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 1)" ] pub mod smmr1 { # [ 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 :: SMMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 1)" ] pub struct CV1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 1)" ] pub mod cv1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV1 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 1)" ] pub struct RA1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 1)" ] pub mod ra1 { # [ 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 :: RA1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 1)" ] pub struct RB1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 1)" ] pub mod rb1 { # [ 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 :: RB1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 1)" ] pub struct RC1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 1)" ] pub mod rc1 { # [ 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 :: RC1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 1)" ] pub struct SR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 1)" ] pub mod sr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR1 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 1)" ] pub struct IER1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 1)" ] pub mod ier1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 1)" ] pub struct IDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 1)" ] pub mod idr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 1)" ] pub struct IMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 1)" ] pub mod imr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR1 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Channel Control Register (channel = 2)" ] pub struct CCR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 2)" ] pub mod ccr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 2)" ] pub struct CMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 2)" ] pub mod cmr2 { # [ 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 :: CMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 2)" ] pub struct CMR2_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 2)" ] pub mod cmr2_wave_eq_1 { # [ 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 :: CMR2_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 2)" ] pub struct SMMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 2)" ] pub mod smmr2 { # [ 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 :: SMMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 2)" ] pub struct CV2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 2)" ] pub mod cv2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV2 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 2)" ] pub struct RA2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 2)" ] pub mod ra2 { # [ 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 :: RA2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 2)" ] pub struct RB2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 2)" ] pub mod rb2 { # [ 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 :: RB2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 2)" ] pub struct RC2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 2)" ] pub mod rc2 { # [ 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 :: RC2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 2)" ] pub struct SR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 2)" ] pub mod sr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR2 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 2)" ] pub struct IER2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 2)" ] pub mod ier2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 2)" ] pub struct IDR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 2)" ] pub mod idr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 2)" ] pub struct IMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 2)" ] pub mod imr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR2 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Block Control Register" ] pub struct BCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Block Control Register" ] pub mod bcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: BCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Synchro Command" ] # [ inline ] pub fn sync ( & mut self ) -> _SYNCW { _SYNCW { w : self } } } } # [ doc = "Block Mode Register" ] pub struct BMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Block Mode Register" ] pub mod bmr { # [ 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 :: BMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TC0XC0S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC0XC0SR { # [ doc = "Signal connected to XC0: TCLK0" ] TCLK0 , # [ doc = "Signal connected to XC0: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC0: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC0XC0SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC0XC0SR :: TCLK0 => 0 , TC0XC0SR :: TIOA1 => 0x02 , TC0XC0SR :: TIOA2 => 0x03 , TC0XC0SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC0XC0SR { match value { 0 => TC0XC0SR :: TCLK0 , 2 => TC0XC0SR :: TIOA1 , 3 => TC0XC0SR :: TIOA2 , i => TC0XC0SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK0`" ] # [ inline ] pub fn is_tclk0 ( & self ) -> bool { * self == TC0XC0SR :: TCLK0 } # [ doc = "Checks if the value of the field is `TIOA1`" ] # [ inline ] pub fn is_tioa1 ( & self ) -> bool { * self == TC0XC0SR :: TIOA1 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC0XC0SR :: TIOA2 } } # [ doc = "Possible values of the field `TC1XC1S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC1XC1SR { # [ doc = "Signal connected to XC1: TCLK1" ] TCLK1 , # [ doc = "Signal connected to XC1: TIOA0" ] TIOA0 , # [ doc = "Signal connected to XC1: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC1XC1SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC1XC1SR :: TCLK1 => 0 , TC1XC1SR :: TIOA0 => 0x02 , TC1XC1SR :: TIOA2 => 0x03 , TC1XC1SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC1XC1SR { match value { 0 => TC1XC1SR :: TCLK1 , 2 => TC1XC1SR :: TIOA0 , 3 => TC1XC1SR :: TIOA2 , i => TC1XC1SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK1`" ] # [ inline ] pub fn is_tclk1 ( & self ) -> bool { * self == TC1XC1SR :: TCLK1 } # [ doc = "Checks if the value of the field is `TIOA0`" ] # [ inline ] pub fn is_tioa0 ( & self ) -> bool { * self == TC1XC1SR :: TIOA0 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC1XC1SR :: TIOA2 } } # [ doc = "Possible values of the field `TC2XC2S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC2XC2SR { # [ doc = "Signal connected to XC2: TCLK2" ] TCLK2 , # [ doc = "Signal connected to XC2: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC2: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC2XC2SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC2XC2SR :: TCLK2 => 0 , TC2XC2SR :: TIOA1 => 0x02 , TC2XC2SR :: TIOA2 => 0x03 , TC2XC2SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC2XC2SR { match value { 0 => TC2XC2SR :: TCLK2 , 2 => TC2XC2SR :: TIOA1 , 3 => TC2XC2SR :: TIOA2 , i => TC2XC2SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK2`" ] # [ inline ] pub fn is_tclk2 ( & self ) -> bool { * self == TC2XC2SR :: TCLK2 } # [ doc = "Checks if the value of the field is `TIOA1`" ] # [ inline ] pub fn is_tioa1 ( & self ) -> bool { * self == TC2XC2SR :: TIOA1 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC2XC2SR :: TIOA2 } } # [ doc = r" Value of the field" ] pub struct QDENR { bits : bool , } impl QDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct POSENR { bits : bool , } impl POSENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SPEEDENR { bits : bool , } impl SPEEDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QDTRANSR { bits : bool , } impl QDTRANSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EDGPHAR { bits : bool , } impl EDGPHAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVAR { bits : bool , } impl INVAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVBR { bits : bool , } impl INVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVIDXR { bits : bool , } impl INVIDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 IDXPHBR { bits : bool , } impl IDXPHBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FILTERR { bits : bool , } impl FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MAXFILTR { bits : u8 , } impl MAXFILTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Values that can be written to the field `TC0XC0S`" ] pub enum TC0XC0SW { # [ doc = "Signal connected to XC0: TCLK0" ] TCLK0 , # [ doc = "Signal connected to XC0: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC0: TIOA2" ] TIOA2 } impl TC0XC0SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC0XC0SW :: TCLK0 => 0 , TC0XC0SW :: TIOA1 => 2 , TC0XC0SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC0XC0SW < 'a > { w : & 'a mut W , } impl < 'a > _TC0XC0SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC0XC0SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC0: TCLK0" ] # [ inline ] pub fn tclk0 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TCLK0 ) } # [ doc = "Signal connected to XC0: TIOA1" ] # [ inline ] pub fn tioa1 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TIOA1 ) } # [ doc = "Signal connected to XC0: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TIOA2 ) } # [ 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 = "Values that can be written to the field `TC1XC1S`" ] pub enum TC1XC1SW { # [ doc = "Signal connected to XC1: TCLK1" ] TCLK1 , # [ doc = "Signal connected to XC1: TIOA0" ] TIOA0 , # [ doc = "Signal connected to XC1: TIOA2" ] TIOA2 } impl TC1XC1SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC1XC1SW :: TCLK1 => 0 , TC1XC1SW :: TIOA0 => 2 , TC1XC1SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC1XC1SW < 'a > { w : & 'a mut W , } impl < 'a > _TC1XC1SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC1XC1SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC1: TCLK1" ] # [ inline ] pub fn tclk1 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TCLK1 ) } # [ doc = "Signal connected to XC1: TIOA0" ] # [ inline ] pub fn tioa0 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TIOA0 ) } # [ doc = "Signal connected to XC1: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TIOA2 ) } # [ 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 = "Values that can be written to the field `TC2XC2S`" ] pub enum TC2XC2SW { # [ doc = "Signal connected to XC2: TCLK2" ] TCLK2 , # [ doc = "Signal connected to XC2: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC2: TIOA2" ] TIOA2 } impl TC2XC2SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC2XC2SW :: TCLK2 => 0 , TC2XC2SW :: TIOA1 => 2 , TC2XC2SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC2XC2SW < 'a > { w : & 'a mut W , } impl < 'a > _TC2XC2SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC2XC2SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC2: TCLK2" ] # [ inline ] pub fn tclk2 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TCLK2 ) } # [ doc = "Signal connected to XC2: TIOA1" ] # [ inline ] pub fn tioa1 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TIOA1 ) } # [ doc = "Signal connected to XC2: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TIOA2 ) } # [ 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 _QDENW < 'a > { w : & 'a mut W , } impl < 'a > _QDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _POSENW < 'a > { w : & 'a mut W , } impl < 'a > _POSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SPEEDENW < 'a > { w : & 'a mut W , } impl < 'a > _SPEEDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QDTRANSW < 'a > { w : & 'a mut W , } impl < 'a > _QDTRANSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EDGPHAW < 'a > { w : & 'a mut W , } impl < 'a > _EDGPHAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVAW < 'a > { w : & 'a mut W , } impl < 'a > _INVAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVBW < 'a > { w : & 'a mut W , } impl < 'a > _INVBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVIDXW < 'a > { w : & 'a mut W , } impl < 'a > _INVIDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _IDXPHBW < 'a > { w : & 'a mut W , } impl < 'a > _IDXPHBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _FILTERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MAXFILTW < 'a > { w : & 'a mut W , } impl < 'a > _MAXFILTW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; const OFFSET : u8 = 20 ; 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 - External Clock Signal 0 Selection" ] # [ inline ] pub fn tc0xc0s ( & self ) -> TC0XC0SR { TC0XC0SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 2:3 - External Clock Signal 1 Selection" ] # [ inline ] pub fn tc1xc1s ( & self ) -> TC1XC1SR { TC1XC1SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - External Clock Signal 2 Selection" ] # [ inline ] pub fn tc2xc2s ( & self ) -> TC2XC2SR { TC2XC2SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Quadrature Decoder ENabled" ] # [ inline ] pub fn qden ( & self ) -> QDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QDENR { bits } } # [ doc = "Bit 9 - POSition ENabled" ] # [ inline ] pub fn posen ( & self ) -> POSENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; POSENR { bits } } # [ doc = "Bit 10 - SPEED ENabled" ] # [ inline ] pub fn speeden ( & self ) -> SPEEDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SPEEDENR { bits } } # [ doc = "Bit 11 - Quadrature Decoding TRANSparent" ] # [ inline ] pub fn qdtrans ( & self ) -> QDTRANSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QDTRANSR { bits } } # [ doc = "Bit 12 - EDGe on PHA count mode" ] # [ inline ] pub fn edgpha ( & self ) -> EDGPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EDGPHAR { bits } } # [ doc = "Bit 13 - INVerted phA" ] # [ inline ] pub fn inva ( & self ) -> INVAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVAR { bits } } # [ doc = "Bit 14 - INVerted phB" ] # [ inline ] pub fn invb ( & self ) -> INVBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVBR { bits } } # [ doc = "Bit 15 - INVerted InDeX" ] # [ inline ] pub fn invidx ( & self ) -> INVIDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVIDXR { bits } } # [ doc = "Bit 16 - SWAP PHA and PHB" ] # [ inline ] pub fn swap ( & self ) -> SWAPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SWAPR { bits } } # [ doc = "Bit 17 - InDeX pin is PHB pin" ] # [ inline ] pub fn idxphb ( & self ) -> IDXPHBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXPHBR { bits } } # [ doc = "Bit 19" ] # [ inline ] pub fn filter ( & self ) -> FILTERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FILTERR { bits } } # [ doc = "Bits 20:25 - MAXimum FILTer" ] # [ inline ] pub fn maxfilt ( & self ) -> MAXFILTR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MAXFILTR { 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 - External Clock Signal 0 Selection" ] # [ inline ] pub fn tc0xc0s ( & mut self ) -> _TC0XC0SW { _TC0XC0SW { w : self } } # [ doc = "Bits 2:3 - External Clock Signal 1 Selection" ] # [ inline ] pub fn tc1xc1s ( & mut self ) -> _TC1XC1SW { _TC1XC1SW { w : self } } # [ doc = "Bits 4:5 - External Clock Signal 2 Selection" ] # [ inline ] pub fn tc2xc2s ( & mut self ) -> _TC2XC2SW { _TC2XC2SW { w : self } } # [ doc = "Bit 8 - Quadrature Decoder ENabled" ] # [ inline ] pub fn qden ( & mut self ) -> _QDENW { _QDENW { w : self } } # [ doc = "Bit 9 - POSition ENabled" ] # [ inline ] pub fn posen ( & mut self ) -> _POSENW { _POSENW { w : self } } # [ doc = "Bit 10 - SPEED ENabled" ] # [ inline ] pub fn speeden ( & mut self ) -> _SPEEDENW { _SPEEDENW { w : self } } # [ doc = "Bit 11 - Quadrature Decoding TRANSparent" ] # [ inline ] pub fn qdtrans ( & mut self ) -> _QDTRANSW { _QDTRANSW { w : self } } # [ doc = "Bit 12 - EDGe on PHA count mode" ] # [ inline ] pub fn edgpha ( & mut self ) -> _EDGPHAW { _EDGPHAW { w : self } } # [ doc = "Bit 13 - INVerted phA" ] # [ inline ] pub fn inva ( & mut self ) -> _INVAW { _INVAW { w : self } } # [ doc = "Bit 14 - INVerted phB" ] # [ inline ] pub fn invb ( & mut self ) -> _INVBW { _INVBW { w : self } } # [ doc = "Bit 15 - INVerted InDeX" ] # [ inline ] pub fn invidx ( & mut self ) -> _INVIDXW { _INVIDXW { w : self } } # [ doc = "Bit 16 - SWAP PHA and PHB" ] # [ inline ] pub fn swap ( & mut self ) -> _SWAPW { _SWAPW { w : self } } # [ doc = "Bit 17 - InDeX pin is PHB pin" ] # [ inline ] pub fn idxphb ( & mut self ) -> _IDXPHBW { _IDXPHBW { w : self } } # [ doc = "Bit 19" ] # [ inline ] pub fn filter ( & mut self ) -> _FILTERW { _FILTERW { w : self } } # [ doc = "Bits 20:25 - MAXimum FILTer" ] # [ inline ] pub fn maxfilt ( & mut self ) -> _MAXFILTW { _MAXFILTW { w : self } } } } # [ doc = "QDEC Interrupt Enable Register" ] pub struct QIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Enable Register" ] pub mod qier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: QIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDXW < 'a > { w : & 'a mut W , } impl < 'a > _IDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIRCHGW < 'a > { w : & 'a mut W , } impl < 'a > _DIRCHGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QERRW < 'a > { w : & 'a mut W , } impl < 'a > _QERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & mut self ) -> _IDXW { _IDXW { w : self } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & mut self ) -> _DIRCHGW { _DIRCHGW { w : self } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & mut self ) -> _QERRW { _QERRW { w : self } } } } # [ doc = "QDEC Interrupt Disable Register" ] pub struct QIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Disable Register" ] pub mod qidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: QIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDXW < 'a > { w : & 'a mut W , } impl < 'a > _IDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIRCHGW < 'a > { w : & 'a mut W , } impl < 'a > _DIRCHGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QERRW < 'a > { w : & 'a mut W , } impl < 'a > _QERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & mut self ) -> _IDXW { _IDXW { w : self } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & mut self ) -> _DIRCHGW { _DIRCHGW { w : self } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & mut self ) -> _QERRW { _QERRW { w : self } } } } # [ doc = "QDEC Interrupt Mask Register" ] pub struct QIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Mask Register" ] pub mod qimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: QIMR { # [ 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 IDXR { bits : bool , } impl IDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIRCHGR { bits : bool , } impl DIRCHGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QERRR { bits : bool , } impl QERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - InDeX" ] # [ inline ] pub fn idx ( & self ) -> IDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXR { bits } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & self ) -> DIRCHGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRCHGR { bits } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & self ) -> QERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QERRR { bits } } } } # [ doc = "QDEC Interrupt Status Register" ] pub struct QISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Status Register" ] pub mod qisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: QISR { # [ 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 IDXR { bits : bool , } impl IDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIRCHGR { bits : bool , } impl DIRCHGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QERRR { bits : bool , } impl QERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ( ) } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & self ) -> IDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXR { bits } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & self ) -> DIRCHGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRCHGR { bits } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & self ) -> QERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QERRR { bits } } # [ doc = "Bit 8 - DIRection" ] # [ inline ] pub fn dir ( & self ) -> DIRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRR { bits } } } } # [ doc = "Fault Mode Register" ] pub struct FMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fault Mode Register" ] pub mod fmr { # [ 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 :: FMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ENCF0R { bits : bool , } impl ENCF0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENCF1R { bits : bool , } impl ENCF1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _ENCF0W < 'a > { w : & 'a mut W , } impl < 'a > _ENCF0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENCF1W < 'a > { w : & 'a mut W , } impl < 'a > _ENCF1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - ENable Compare Fault Channel 0" ] # [ inline ] pub fn encf0 ( & self ) -> ENCF0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENCF0R { bits } } # [ doc = "Bit 1 - ENable Compare Fault Channel 1" ] # [ inline ] pub fn encf1 ( & self ) -> ENCF1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENCF1R { 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 - ENable Compare Fault Channel 0" ] # [ inline ] pub fn encf0 ( & mut self ) -> _ENCF0W { _ENCF0W { w : self } } # [ doc = "Bit 1 - ENable Compare Fault Channel 1" ] # [ inline ] pub fn encf1 ( & mut self ) -> _ENCF1W { _ENCF1W { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0054_494d , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5523789 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5523789 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } } # [ doc = "Timer Counter 1" ] pub struct TC1 { _marker : PhantomData < * const ( ) > } unsafe impl Send for TC1 { } impl TC1 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const tc1 :: RegisterBlock { 0x4008_4000 as * const _ } } impl Deref for TC1 { type Target = tc1 :: RegisterBlock ; fn deref ( & self ) -> & tc1 :: RegisterBlock { unsafe { & * TC1 :: ptr ( ) } } } # [ doc = "Timer Counter 1" ] pub mod tc1 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Channel Control Register (channel = 0)" ] pub ccr0 : CCR0 , # [ doc = "Channel Mode Register (channel = 0)" ] pub cmr0 : CMR0_UNION , # [ doc = "0x08 - Stepper Motor Mode Register (channel = 0)" ] pub smmr0 : SMMR0 , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Counter Value (channel = 0)" ] pub cv0 : CV0 , # [ doc = "0x14 - Register A (channel = 0)" ] pub ra0 : RA0 , # [ doc = "0x18 - Register B (channel = 0)" ] pub rb0 : RB0 , # [ doc = "0x1c - Register C (channel = 0)" ] pub rc0 : RC0 , # [ doc = "0x20 - Status Register (channel = 0)" ] pub sr0 : SR0 , # [ doc = "0x24 - Interrupt Enable Register (channel = 0)" ] pub ier0 : IER0 , # [ doc = "0x28 - Interrupt Disable Register (channel = 0)" ] pub idr0 : IDR0 , # [ doc = "0x2c - Interrupt Mask Register (channel = 0)" ] pub imr0 : IMR0 , _reserved11 : [ u8 ; 16usize ] , # [ doc = "0x40 - Channel Control Register (channel = 1)" ] pub ccr1 : CCR1 , # [ doc = "Channel Mode Register (channel = 1)" ] pub cmr1 : CMR1_UNION , # [ doc = "0x48 - Stepper Motor Mode Register (channel = 1)" ] pub smmr1 : SMMR1 , _reserved14 : [ u8 ; 4usize ] , # [ doc = "0x50 - Counter Value (channel = 1)" ] pub cv1 : CV1 , # [ doc = "0x54 - Register A (channel = 1)" ] pub ra1 : RA1 , # [ doc = "0x58 - Register B (channel = 1)" ] pub rb1 : RB1 , # [ doc = "0x5c - Register C (channel = 1)" ] pub rc1 : RC1 , # [ doc = "0x60 - Status Register (channel = 1)" ] pub sr1 : SR1 , # [ doc = "0x64 - Interrupt Enable Register (channel = 1)" ] pub ier1 : IER1 , # [ doc = "0x68 - Interrupt Disable Register (channel = 1)" ] pub idr1 : IDR1 , # [ doc = "0x6c - Interrupt Mask Register (channel = 1)" ] pub imr1 : IMR1 , _reserved22 : [ u8 ; 16usize ] , # [ doc = "0x80 - Channel Control Register (channel = 2)" ] pub ccr2 : CCR2 , # [ doc = "Channel Mode Register (channel = 2)" ] pub cmr2 : CMR2_UNION , # [ doc = "0x88 - Stepper Motor Mode Register (channel = 2)" ] pub smmr2 : SMMR2 , _reserved25 : [ u8 ; 4usize ] , # [ doc = "0x90 - Counter Value (channel = 2)" ] pub cv2 : CV2 , # [ doc = "0x94 - Register A (channel = 2)" ] pub ra2 : RA2 , # [ doc = "0x98 - Register B (channel = 2)" ] pub rb2 : RB2 , # [ doc = "0x9c - Register C (channel = 2)" ] pub rc2 : RC2 , # [ doc = "0xa0 - Status Register (channel = 2)" ] pub sr2 : SR2 , # [ doc = "0xa4 - Interrupt Enable Register (channel = 2)" ] pub ier2 : IER2 , # [ doc = "0xa8 - Interrupt Disable Register (channel = 2)" ] pub idr2 : IDR2 , # [ doc = "0xac - Interrupt Mask Register (channel = 2)" ] pub imr2 : IMR2 , _reserved33 : [ u8 ; 16usize ] , # [ doc = "0xc0 - Block Control Register" ] pub bcr : BCR , # [ doc = "0xc4 - Block Mode Register" ] pub bmr : BMR , # [ doc = "0xc8 - QDEC Interrupt Enable Register" ] pub qier : QIER , # [ doc = "0xcc - QDEC Interrupt Disable Register" ] pub qidr : QIDR , # [ doc = "0xd0 - QDEC Interrupt Mask Register" ] pub qimr : QIMR , # [ doc = "0xd4 - QDEC Interrupt Status Register" ] pub qisr : QISR , # [ doc = "0xd8 - Fault Mode Register" ] pub fmr : FMR , _reserved40 : [ u8 ; 8usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , } # [ doc = "Channel Mode Register (channel = 0)" ] # [ repr ( C ) ] pub union CMR0_UNION { # [ doc = "0x04 - Channel Mode Register (channel = 0)" ] pub cmr0_wave_eq_1 : CMR0_WAVE_EQ_1 , # [ doc = "0x04 - Channel Mode Register (channel = 0)" ] pub cmr0 : CMR0 , } # [ doc = "Channel Mode Register (channel = 1)" ] # [ repr ( C ) ] pub union CMR1_UNION { # [ doc = "0x44 - Channel Mode Register (channel = 1)" ] pub cmr1_wave_eq_1 : CMR1_WAVE_EQ_1 , # [ doc = "0x44 - Channel Mode Register (channel = 1)" ] pub cmr1 : CMR1 , } # [ doc = "Channel Mode Register (channel = 2)" ] # [ repr ( C ) ] pub union CMR2_UNION { # [ doc = "0x84 - Channel Mode Register (channel = 2)" ] pub cmr2_wave_eq_1 : CMR2_WAVE_EQ_1 , # [ doc = "0x84 - Channel Mode Register (channel = 2)" ] pub cmr2 : CMR2 , } # [ doc = "Channel Control Register (channel = 0)" ] pub struct CCR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 0)" ] pub mod ccr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 0)" ] pub struct CMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 0)" ] pub mod cmr0 { # [ 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 :: CMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 0)" ] pub struct CMR0_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 0)" ] pub mod cmr0_wave_eq_1 { # [ 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 :: CMR0_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 0)" ] pub struct SMMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 0)" ] pub mod smmr0 { # [ 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 :: SMMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 0)" ] pub struct CV0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 0)" ] pub mod cv0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV0 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 0)" ] pub struct RA0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 0)" ] pub mod ra0 { # [ 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 :: RA0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 0)" ] pub struct RB0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 0)" ] pub mod rb0 { # [ 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 :: RB0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 0)" ] pub struct RC0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 0)" ] pub mod rc0 { # [ 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 :: RC0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 0)" ] pub struct SR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 0)" ] pub mod sr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR0 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 0)" ] pub struct IER0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 0)" ] pub mod ier0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 0)" ] pub struct IDR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 0)" ] pub mod idr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 0)" ] pub struct IMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 0)" ] pub mod imr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR0 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Channel Control Register (channel = 1)" ] pub struct CCR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 1)" ] pub mod ccr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 1)" ] pub struct CMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 1)" ] pub mod cmr1 { # [ 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 :: CMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 1)" ] pub struct CMR1_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 1)" ] pub mod cmr1_wave_eq_1 { # [ 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 :: CMR1_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 1)" ] pub struct SMMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 1)" ] pub mod smmr1 { # [ 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 :: SMMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 1)" ] pub struct CV1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 1)" ] pub mod cv1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV1 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 1)" ] pub struct RA1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 1)" ] pub mod ra1 { # [ 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 :: RA1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 1)" ] pub struct RB1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 1)" ] pub mod rb1 { # [ 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 :: RB1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 1)" ] pub struct RC1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 1)" ] pub mod rc1 { # [ 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 :: RC1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 1)" ] pub struct SR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 1)" ] pub mod sr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR1 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 1)" ] pub struct IER1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 1)" ] pub mod ier1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 1)" ] pub struct IDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 1)" ] pub mod idr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 1)" ] pub struct IMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 1)" ] pub mod imr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR1 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Channel Control Register (channel = 2)" ] pub struct CCR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 2)" ] pub mod ccr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 2)" ] pub struct CMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 2)" ] pub mod cmr2 { # [ 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 :: CMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 2)" ] pub struct CMR2_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 2)" ] pub mod cmr2_wave_eq_1 { # [ 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 :: CMR2_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 2)" ] pub struct SMMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 2)" ] pub mod smmr2 { # [ 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 :: SMMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 2)" ] pub struct CV2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 2)" ] pub mod cv2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV2 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 2)" ] pub struct RA2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 2)" ] pub mod ra2 { # [ 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 :: RA2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 2)" ] pub struct RB2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 2)" ] pub mod rb2 { # [ 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 :: RB2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 2)" ] pub struct RC2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 2)" ] pub mod rc2 { # [ 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 :: RC2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 2)" ] pub struct SR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 2)" ] pub mod sr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR2 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 2)" ] pub struct IER2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 2)" ] pub mod ier2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 2)" ] pub struct IDR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 2)" ] pub mod idr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 2)" ] pub struct IMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 2)" ] pub mod imr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR2 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Block Control Register" ] pub struct BCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Block Control Register" ] pub mod bcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: BCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Synchro Command" ] # [ inline ] pub fn sync ( & mut self ) -> _SYNCW { _SYNCW { w : self } } } } # [ doc = "Block Mode Register" ] pub struct BMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Block Mode Register" ] pub mod bmr { # [ 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 :: BMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TC0XC0S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC0XC0SR { # [ doc = "Signal connected to XC0: TCLK0" ] TCLK0 , # [ doc = "Signal connected to XC0: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC0: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC0XC0SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC0XC0SR :: TCLK0 => 0 , TC0XC0SR :: TIOA1 => 0x02 , TC0XC0SR :: TIOA2 => 0x03 , TC0XC0SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC0XC0SR { match value { 0 => TC0XC0SR :: TCLK0 , 2 => TC0XC0SR :: TIOA1 , 3 => TC0XC0SR :: TIOA2 , i => TC0XC0SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK0`" ] # [ inline ] pub fn is_tclk0 ( & self ) -> bool { * self == TC0XC0SR :: TCLK0 } # [ doc = "Checks if the value of the field is `TIOA1`" ] # [ inline ] pub fn is_tioa1 ( & self ) -> bool { * self == TC0XC0SR :: TIOA1 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC0XC0SR :: TIOA2 } } # [ doc = "Possible values of the field `TC1XC1S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC1XC1SR { # [ doc = "Signal connected to XC1: TCLK1" ] TCLK1 , # [ doc = "Signal connected to XC1: TIOA0" ] TIOA0 , # [ doc = "Signal connected to XC1: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC1XC1SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC1XC1SR :: TCLK1 => 0 , TC1XC1SR :: TIOA0 => 0x02 , TC1XC1SR :: TIOA2 => 0x03 , TC1XC1SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC1XC1SR { match value { 0 => TC1XC1SR :: TCLK1 , 2 => TC1XC1SR :: TIOA0 , 3 => TC1XC1SR :: TIOA2 , i => TC1XC1SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK1`" ] # [ inline ] pub fn is_tclk1 ( & self ) -> bool { * self == TC1XC1SR :: TCLK1 } # [ doc = "Checks if the value of the field is `TIOA0`" ] # [ inline ] pub fn is_tioa0 ( & self ) -> bool { * self == TC1XC1SR :: TIOA0 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC1XC1SR :: TIOA2 } } # [ doc = "Possible values of the field `TC2XC2S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC2XC2SR { # [ doc = "Signal connected to XC2: TCLK2" ] TCLK2 , # [ doc = "Signal connected to XC2: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC2: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC2XC2SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC2XC2SR :: TCLK2 => 0 , TC2XC2SR :: TIOA1 => 0x02 , TC2XC2SR :: TIOA2 => 0x03 , TC2XC2SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC2XC2SR { match value { 0 => TC2XC2SR :: TCLK2 , 2 => TC2XC2SR :: TIOA1 , 3 => TC2XC2SR :: TIOA2 , i => TC2XC2SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK2`" ] # [ inline ] pub fn is_tclk2 ( & self ) -> bool { * self == TC2XC2SR :: TCLK2 } # [ doc = "Checks if the value of the field is `TIOA1`" ] # [ inline ] pub fn is_tioa1 ( & self ) -> bool { * self == TC2XC2SR :: TIOA1 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC2XC2SR :: TIOA2 } } # [ doc = r" Value of the field" ] pub struct QDENR { bits : bool , } impl QDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct POSENR { bits : bool , } impl POSENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SPEEDENR { bits : bool , } impl SPEEDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QDTRANSR { bits : bool , } impl QDTRANSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EDGPHAR { bits : bool , } impl EDGPHAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVAR { bits : bool , } impl INVAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVBR { bits : bool , } impl INVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVIDXR { bits : bool , } impl INVIDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 IDXPHBR { bits : bool , } impl IDXPHBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FILTERR { bits : bool , } impl FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MAXFILTR { bits : u8 , } impl MAXFILTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Values that can be written to the field `TC0XC0S`" ] pub enum TC0XC0SW { # [ doc = "Signal connected to XC0: TCLK0" ] TCLK0 , # [ doc = "Signal connected to XC0: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC0: TIOA2" ] TIOA2 } impl TC0XC0SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC0XC0SW :: TCLK0 => 0 , TC0XC0SW :: TIOA1 => 2 , TC0XC0SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC0XC0SW < 'a > { w : & 'a mut W , } impl < 'a > _TC0XC0SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC0XC0SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC0: TCLK0" ] # [ inline ] pub fn tclk0 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TCLK0 ) } # [ doc = "Signal connected to XC0: TIOA1" ] # [ inline ] pub fn tioa1 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TIOA1 ) } # [ doc = "Signal connected to XC0: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TIOA2 ) } # [ 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 = "Values that can be written to the field `TC1XC1S`" ] pub enum TC1XC1SW { # [ doc = "Signal connected to XC1: TCLK1" ] TCLK1 , # [ doc = "Signal connected to XC1: TIOA0" ] TIOA0 , # [ doc = "Signal connected to XC1: TIOA2" ] TIOA2 } impl TC1XC1SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC1XC1SW :: TCLK1 => 0 , TC1XC1SW :: TIOA0 => 2 , TC1XC1SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC1XC1SW < 'a > { w : & 'a mut W , } impl < 'a > _TC1XC1SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC1XC1SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC1: TCLK1" ] # [ inline ] pub fn tclk1 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TCLK1 ) } # [ doc = "Signal connected to XC1: TIOA0" ] # [ inline ] pub fn tioa0 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TIOA0 ) } # [ doc = "Signal connected to XC1: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TIOA2 ) } # [ 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 = "Values that can be written to the field `TC2XC2S`" ] pub enum TC2XC2SW { # [ doc = "Signal connected to XC2: TCLK2" ] TCLK2 , # [ doc = "Signal connected to XC2: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC2: TIOA2" ] TIOA2 } impl TC2XC2SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC2XC2SW :: TCLK2 => 0 , TC2XC2SW :: TIOA1 => 2 , TC2XC2SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC2XC2SW < 'a > { w : & 'a mut W , } impl < 'a > _TC2XC2SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC2XC2SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC2: TCLK2" ] # [ inline ] pub fn tclk2 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TCLK2 ) } # [ doc = "Signal connected to XC2: TIOA1" ] # [ inline ] pub fn tioa1 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TIOA1 ) } # [ doc = "Signal connected to XC2: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TIOA2 ) } # [ 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 _QDENW < 'a > { w : & 'a mut W , } impl < 'a > _QDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _POSENW < 'a > { w : & 'a mut W , } impl < 'a > _POSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SPEEDENW < 'a > { w : & 'a mut W , } impl < 'a > _SPEEDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QDTRANSW < 'a > { w : & 'a mut W , } impl < 'a > _QDTRANSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EDGPHAW < 'a > { w : & 'a mut W , } impl < 'a > _EDGPHAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVAW < 'a > { w : & 'a mut W , } impl < 'a > _INVAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVBW < 'a > { w : & 'a mut W , } impl < 'a > _INVBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVIDXW < 'a > { w : & 'a mut W , } impl < 'a > _INVIDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _IDXPHBW < 'a > { w : & 'a mut W , } impl < 'a > _IDXPHBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _FILTERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MAXFILTW < 'a > { w : & 'a mut W , } impl < 'a > _MAXFILTW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; const OFFSET : u8 = 20 ; 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 - External Clock Signal 0 Selection" ] # [ inline ] pub fn tc0xc0s ( & self ) -> TC0XC0SR { TC0XC0SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 2:3 - External Clock Signal 1 Selection" ] # [ inline ] pub fn tc1xc1s ( & self ) -> TC1XC1SR { TC1XC1SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - External Clock Signal 2 Selection" ] # [ inline ] pub fn tc2xc2s ( & self ) -> TC2XC2SR { TC2XC2SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Quadrature Decoder ENabled" ] # [ inline ] pub fn qden ( & self ) -> QDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QDENR { bits } } # [ doc = "Bit 9 - POSition ENabled" ] # [ inline ] pub fn posen ( & self ) -> POSENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; POSENR { bits } } # [ doc = "Bit 10 - SPEED ENabled" ] # [ inline ] pub fn speeden ( & self ) -> SPEEDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SPEEDENR { bits } } # [ doc = "Bit 11 - Quadrature Decoding TRANSparent" ] # [ inline ] pub fn qdtrans ( & self ) -> QDTRANSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QDTRANSR { bits } } # [ doc = "Bit 12 - EDGe on PHA count mode" ] # [ inline ] pub fn edgpha ( & self ) -> EDGPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EDGPHAR { bits } } # [ doc = "Bit 13 - INVerted phA" ] # [ inline ] pub fn inva ( & self ) -> INVAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVAR { bits } } # [ doc = "Bit 14 - INVerted phB" ] # [ inline ] pub fn invb ( & self ) -> INVBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVBR { bits } } # [ doc = "Bit 15 - INVerted InDeX" ] # [ inline ] pub fn invidx ( & self ) -> INVIDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVIDXR { bits } } # [ doc = "Bit 16 - SWAP PHA and PHB" ] # [ inline ] pub fn swap ( & self ) -> SWAPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SWAPR { bits } } # [ doc = "Bit 17 - InDeX pin is PHB pin" ] # [ inline ] pub fn idxphb ( & self ) -> IDXPHBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXPHBR { bits } } # [ doc = "Bit 19" ] # [ inline ] pub fn filter ( & self ) -> FILTERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FILTERR { bits } } # [ doc = "Bits 20:25 - MAXimum FILTer" ] # [ inline ] pub fn maxfilt ( & self ) -> MAXFILTR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MAXFILTR { 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 - External Clock Signal 0 Selection" ] # [ inline ] pub fn tc0xc0s ( & mut self ) -> _TC0XC0SW { _TC0XC0SW { w : self } } # [ doc = "Bits 2:3 - External Clock Signal 1 Selection" ] # [ inline ] pub fn tc1xc1s ( & mut self ) -> _TC1XC1SW { _TC1XC1SW { w : self } } # [ doc = "Bits 4:5 - External Clock Signal 2 Selection" ] # [ inline ] pub fn tc2xc2s ( & mut self ) -> _TC2XC2SW { _TC2XC2SW { w : self } } # [ doc = "Bit 8 - Quadrature Decoder ENabled" ] # [ inline ] pub fn qden ( & mut self ) -> _QDENW { _QDENW { w : self } } # [ doc = "Bit 9 - POSition ENabled" ] # [ inline ] pub fn posen ( & mut self ) -> _POSENW { _POSENW { w : self } } # [ doc = "Bit 10 - SPEED ENabled" ] # [ inline ] pub fn speeden ( & mut self ) -> _SPEEDENW { _SPEEDENW { w : self } } # [ doc = "Bit 11 - Quadrature Decoding TRANSparent" ] # [ inline ] pub fn qdtrans ( & mut self ) -> _QDTRANSW { _QDTRANSW { w : self } } # [ doc = "Bit 12 - EDGe on PHA count mode" ] # [ inline ] pub fn edgpha ( & mut self ) -> _EDGPHAW { _EDGPHAW { w : self } } # [ doc = "Bit 13 - INVerted phA" ] # [ inline ] pub fn inva ( & mut self ) -> _INVAW { _INVAW { w : self } } # [ doc = "Bit 14 - INVerted phB" ] # [ inline ] pub fn invb ( & mut self ) -> _INVBW { _INVBW { w : self } } # [ doc = "Bit 15 - INVerted InDeX" ] # [ inline ] pub fn invidx ( & mut self ) -> _INVIDXW { _INVIDXW { w : self } } # [ doc = "Bit 16 - SWAP PHA and PHB" ] # [ inline ] pub fn swap ( & mut self ) -> _SWAPW { _SWAPW { w : self } } # [ doc = "Bit 17 - InDeX pin is PHB pin" ] # [ inline ] pub fn idxphb ( & mut self ) -> _IDXPHBW { _IDXPHBW { w : self } } # [ doc = "Bit 19" ] # [ inline ] pub fn filter ( & mut self ) -> _FILTERW { _FILTERW { w : self } } # [ doc = "Bits 20:25 - MAXimum FILTer" ] # [ inline ] pub fn maxfilt ( & mut self ) -> _MAXFILTW { _MAXFILTW { w : self } } } } # [ doc = "QDEC Interrupt Enable Register" ] pub struct QIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Enable Register" ] pub mod qier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: QIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDXW < 'a > { w : & 'a mut W , } impl < 'a > _IDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIRCHGW < 'a > { w : & 'a mut W , } impl < 'a > _DIRCHGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QERRW < 'a > { w : & 'a mut W , } impl < 'a > _QERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & mut self ) -> _IDXW { _IDXW { w : self } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & mut self ) -> _DIRCHGW { _DIRCHGW { w : self } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & mut self ) -> _QERRW { _QERRW { w : self } } } } # [ doc = "QDEC Interrupt Disable Register" ] pub struct QIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Disable Register" ] pub mod qidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: QIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDXW < 'a > { w : & 'a mut W , } impl < 'a > _IDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIRCHGW < 'a > { w : & 'a mut W , } impl < 'a > _DIRCHGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QERRW < 'a > { w : & 'a mut W , } impl < 'a > _QERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & mut self ) -> _IDXW { _IDXW { w : self } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & mut self ) -> _DIRCHGW { _DIRCHGW { w : self } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & mut self ) -> _QERRW { _QERRW { w : self } } } } # [ doc = "QDEC Interrupt Mask Register" ] pub struct QIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Mask Register" ] pub mod qimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: QIMR { # [ 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 IDXR { bits : bool , } impl IDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIRCHGR { bits : bool , } impl DIRCHGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QERRR { bits : bool , } impl QERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - InDeX" ] # [ inline ] pub fn idx ( & self ) -> IDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXR { bits } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & self ) -> DIRCHGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRCHGR { bits } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & self ) -> QERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QERRR { bits } } } } # [ doc = "QDEC Interrupt Status Register" ] pub struct QISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Status Register" ] pub mod qisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: QISR { # [ 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 IDXR { bits : bool , } impl IDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIRCHGR { bits : bool , } impl DIRCHGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QERRR { bits : bool , } impl QERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ( ) } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & self ) -> IDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXR { bits } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & self ) -> DIRCHGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRCHGR { bits } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & self ) -> QERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QERRR { bits } } # [ doc = "Bit 8 - DIRection" ] # [ inline ] pub fn dir ( & self ) -> DIRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRR { bits } } } } # [ doc = "Fault Mode Register" ] pub struct FMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fault Mode Register" ] pub mod fmr { # [ 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 :: FMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ENCF0R { bits : bool , } impl ENCF0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENCF1R { bits : bool , } impl ENCF1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _ENCF0W < 'a > { w : & 'a mut W , } impl < 'a > _ENCF0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENCF1W < 'a > { w : & 'a mut W , } impl < 'a > _ENCF1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - ENable Compare Fault Channel 0" ] # [ inline ] pub fn encf0 ( & self ) -> ENCF0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENCF0R { bits } } # [ doc = "Bit 1 - ENable Compare Fault Channel 1" ] # [ inline ] pub fn encf1 ( & self ) -> ENCF1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENCF1R { 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 - ENable Compare Fault Channel 0" ] # [ inline ] pub fn encf0 ( & mut self ) -> _ENCF0W { _ENCF0W { w : self } } # [ doc = "Bit 1 - ENable Compare Fault Channel 1" ] # [ inline ] pub fn encf1 ( & mut self ) -> _ENCF1W { _ENCF1W { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0054_494d , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5523789 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5523789 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } } # [ doc = "Timer Counter 2" ] pub struct TC2 { _marker : PhantomData < * const ( ) > } unsafe impl Send for TC2 { } impl TC2 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const tc2 :: RegisterBlock { 0x4008_8000 as * const _ } } impl Deref for TC2 { type Target = tc2 :: RegisterBlock ; fn deref ( & self ) -> & tc2 :: RegisterBlock { unsafe { & * TC2 :: ptr ( ) } } } # [ doc = "Timer Counter 2" ] pub mod tc2 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Channel Control Register (channel = 0)" ] pub ccr0 : CCR0 , # [ doc = "Channel Mode Register (channel = 0)" ] pub cmr0 : CMR0_UNION , # [ doc = "0x08 - Stepper Motor Mode Register (channel = 0)" ] pub smmr0 : SMMR0 , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Counter Value (channel = 0)" ] pub cv0 : CV0 , # [ doc = "0x14 - Register A (channel = 0)" ] pub ra0 : RA0 , # [ doc = "0x18 - Register B (channel = 0)" ] pub rb0 : RB0 , # [ doc = "0x1c - Register C (channel = 0)" ] pub rc0 : RC0 , # [ doc = "0x20 - Status Register (channel = 0)" ] pub sr0 : SR0 , # [ doc = "0x24 - Interrupt Enable Register (channel = 0)" ] pub ier0 : IER0 , # [ doc = "0x28 - Interrupt Disable Register (channel = 0)" ] pub idr0 : IDR0 , # [ doc = "0x2c - Interrupt Mask Register (channel = 0)" ] pub imr0 : IMR0 , _reserved11 : [ u8 ; 16usize ] , # [ doc = "0x40 - Channel Control Register (channel = 1)" ] pub ccr1 : CCR1 , # [ doc = "Channel Mode Register (channel = 1)" ] pub cmr1 : CMR1_UNION , # [ doc = "0x48 - Stepper Motor Mode Register (channel = 1)" ] pub smmr1 : SMMR1 , _reserved14 : [ u8 ; 4usize ] , # [ doc = "0x50 - Counter Value (channel = 1)" ] pub cv1 : CV1 , # [ doc = "0x54 - Register A (channel = 1)" ] pub ra1 : RA1 , # [ doc = "0x58 - Register B (channel = 1)" ] pub rb1 : RB1 , # [ doc = "0x5c - Register C (channel = 1)" ] pub rc1 : RC1 , # [ doc = "0x60 - Status Register (channel = 1)" ] pub sr1 : SR1 , # [ doc = "0x64 - Interrupt Enable Register (channel = 1)" ] pub ier1 : IER1 , # [ doc = "0x68 - Interrupt Disable Register (channel = 1)" ] pub idr1 : IDR1 , # [ doc = "0x6c - Interrupt Mask Register (channel = 1)" ] pub imr1 : IMR1 , _reserved22 : [ u8 ; 16usize ] , # [ doc = "0x80 - Channel Control Register (channel = 2)" ] pub ccr2 : CCR2 , # [ doc = "Channel Mode Register (channel = 2)" ] pub cmr2 : CMR2_UNION , # [ doc = "0x88 - Stepper Motor Mode Register (channel = 2)" ] pub smmr2 : SMMR2 , _reserved25 : [ u8 ; 4usize ] , # [ doc = "0x90 - Counter Value (channel = 2)" ] pub cv2 : CV2 , # [ doc = "0x94 - Register A (channel = 2)" ] pub ra2 : RA2 , # [ doc = "0x98 - Register B (channel = 2)" ] pub rb2 : RB2 , # [ doc = "0x9c - Register C (channel = 2)" ] pub rc2 : RC2 , # [ doc = "0xa0 - Status Register (channel = 2)" ] pub sr2 : SR2 , # [ doc = "0xa4 - Interrupt Enable Register (channel = 2)" ] pub ier2 : IER2 , # [ doc = "0xa8 - Interrupt Disable Register (channel = 2)" ] pub idr2 : IDR2 , # [ doc = "0xac - Interrupt Mask Register (channel = 2)" ] pub imr2 : IMR2 , _reserved33 : [ u8 ; 16usize ] , # [ doc = "0xc0 - Block Control Register" ] pub bcr : BCR , # [ doc = "0xc4 - Block Mode Register" ] pub bmr : BMR , # [ doc = "0xc8 - QDEC Interrupt Enable Register" ] pub qier : QIER , # [ doc = "0xcc - QDEC Interrupt Disable Register" ] pub qidr : QIDR , # [ doc = "0xd0 - QDEC Interrupt Mask Register" ] pub qimr : QIMR , # [ doc = "0xd4 - QDEC Interrupt Status Register" ] pub qisr : QISR , # [ doc = "0xd8 - Fault Mode Register" ] pub fmr : FMR , _reserved40 : [ u8 ; 8usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , } # [ doc = "Channel Mode Register (channel = 0)" ] # [ repr ( C ) ] pub union CMR0_UNION { # [ doc = "0x04 - Channel Mode Register (channel = 0)" ] pub cmr0_wave_eq_1 : CMR0_WAVE_EQ_1 , # [ doc = "0x04 - Channel Mode Register (channel = 0)" ] pub cmr0 : CMR0 , } # [ doc = "Channel Mode Register (channel = 1)" ] # [ repr ( C ) ] pub union CMR1_UNION { # [ doc = "0x44 - Channel Mode Register (channel = 1)" ] pub cmr1_wave_eq_1 : CMR1_WAVE_EQ_1 , # [ doc = "0x44 - Channel Mode Register (channel = 1)" ] pub cmr1 : CMR1 , } # [ doc = "Channel Mode Register (channel = 2)" ] # [ repr ( C ) ] pub union CMR2_UNION { # [ doc = "0x84 - Channel Mode Register (channel = 2)" ] pub cmr2_wave_eq_1 : CMR2_WAVE_EQ_1 , # [ doc = "0x84 - Channel Mode Register (channel = 2)" ] pub cmr2 : CMR2 , } # [ doc = "Channel Control Register (channel = 0)" ] pub struct CCR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 0)" ] pub mod ccr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 0)" ] pub struct CMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 0)" ] pub mod cmr0 { # [ 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 :: CMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 0)" ] pub struct CMR0_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 0)" ] pub mod cmr0_wave_eq_1 { # [ 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 :: CMR0_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 0)" ] pub struct SMMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 0)" ] pub mod smmr0 { # [ 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 :: SMMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 0)" ] pub struct CV0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 0)" ] pub mod cv0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV0 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 0)" ] pub struct RA0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 0)" ] pub mod ra0 { # [ 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 :: RA0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 0)" ] pub struct RB0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 0)" ] pub mod rb0 { # [ 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 :: RB0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 0)" ] pub struct RC0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 0)" ] pub mod rc0 { # [ 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 :: RC0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 0)" ] pub struct SR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 0)" ] pub mod sr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR0 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 0)" ] pub struct IER0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 0)" ] pub mod ier0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 0)" ] pub struct IDR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 0)" ] pub mod idr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 0)" ] pub struct IMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 0)" ] pub mod imr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR0 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Channel Control Register (channel = 1)" ] pub struct CCR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 1)" ] pub mod ccr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 1)" ] pub struct CMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 1)" ] pub mod cmr1 { # [ 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 :: CMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 1)" ] pub struct CMR1_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 1)" ] pub mod cmr1_wave_eq_1 { # [ 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 :: CMR1_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 1)" ] pub struct SMMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 1)" ] pub mod smmr1 { # [ 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 :: SMMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 1)" ] pub struct CV1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 1)" ] pub mod cv1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV1 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 1)" ] pub struct RA1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 1)" ] pub mod ra1 { # [ 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 :: RA1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 1)" ] pub struct RB1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 1)" ] pub mod rb1 { # [ 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 :: RB1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 1)" ] pub struct RC1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 1)" ] pub mod rc1 { # [ 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 :: RC1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 1)" ] pub struct SR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 1)" ] pub mod sr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR1 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 1)" ] pub struct IER1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 1)" ] pub mod ier1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 1)" ] pub struct IDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 1)" ] pub mod idr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 1)" ] pub struct IMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 1)" ] pub mod imr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR1 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Channel Control Register (channel = 2)" ] pub struct CCR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Control Register (channel = 2)" ] pub mod ccr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CCR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CLKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CLKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _SWTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Clock Enable Command" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } # [ doc = "Bit 1 - Counter Clock Disable Command" ] # [ inline ] pub fn clkdis ( & mut self ) -> _CLKDISW { _CLKDISW { w : self } } # [ doc = "Bit 2 - Software Trigger Command" ] # [ inline ] pub fn swtrg ( & mut self ) -> _SWTRGW { _SWTRGW { w : self } } } } # [ doc = "Channel Mode Register (channel = 2)" ] pub struct CMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 2)" ] pub mod cmr2 { # [ 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 :: CMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct LDBSTOPR { bits : bool , } impl LDBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDBDISR { bits : bool , } impl LDBDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ETRGEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ETRGEDGR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ETRGEDGR :: NONE => 0 , ETRGEDGR :: RISING => 0x01 , ETRGEDGR :: FALLING => 0x02 , ETRGEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ETRGEDGR { match value { 0 => ETRGEDGR :: NONE , 1 => ETRGEDGR :: RISING , 2 => ETRGEDGR :: FALLING , 3 => ETRGEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ETRGEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == ETRGEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == ETRGEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == ETRGEDGR :: EDGE } } # [ doc = r" Value of the field" ] pub struct ABETRGR { bits : bool , } impl ABETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCTRGR { bits : bool , } impl CPCTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `LDRA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRAR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRAR :: NONE => 0 , LDRAR :: RISING => 0x01 , LDRAR :: FALLING => 0x02 , LDRAR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRAR { match value { 0 => LDRAR :: NONE , 1 => LDRAR :: RISING , 2 => LDRAR :: FALLING , 3 => LDRAR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRAR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRAR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRAR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRAR :: EDGE } } # [ doc = "Possible values of the field `LDRB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LDRBR { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { LDRBR :: NONE => 0 , LDRBR :: RISING => 0x01 , LDRBR :: FALLING => 0x02 , LDRBR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> LDRBR { match value { 0 => LDRBR :: NONE , 1 => LDRBR :: RISING , 2 => LDRBR :: FALLING , 3 => LDRBR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == LDRBR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == LDRBR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == LDRBR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == LDRBR :: EDGE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LDBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _LDBSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDBDISW < 'a > { w : & 'a mut W , } impl < 'a > _LDBDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ETRGEDG`" ] pub enum ETRGEDGW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl ETRGEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ETRGEDGW :: NONE => 0 , ETRGEDGW :: RISING => 1 , ETRGEDGW :: FALLING => 2 , ETRGEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _ETRGEDGW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ETRGEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( ETRGEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ABETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ABETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCTRGW < 'a > { w : & 'a mut W , } impl < 'a > _CPCTRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LDRA`" ] pub enum LDRAW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRAW :: NONE => 0 , LDRAW :: RISING => 1 , LDRAW :: FALLING => 2 , LDRAW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRAW < 'a > { w : & 'a mut W , } impl < 'a > _LDRAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRAW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRAW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRAW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRAW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `LDRB`" ] pub enum LDRBW { # [ doc = "None" ] NONE , # [ doc = "Rising edge of TIOA" ] RISING , # [ doc = "Falling edge of TIOA" ] FALLING , # [ doc = "Each edge of TIOA" ] EDGE } impl LDRBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { LDRBW :: NONE => 0 , LDRBW :: RISING => 1 , LDRBW :: FALLING => 2 , LDRBW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _LDRBW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LDRBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( LDRBW :: NONE ) } # [ doc = "Rising edge of TIOA" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( LDRBW :: RISING ) } # [ doc = "Falling edge of TIOA" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( LDRBW :: FALLING ) } # [ doc = "Each edge of TIOA" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( LDRBW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & self ) -> LDBSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & self ) -> LDBDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDBDISR { bits } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & self ) -> ETRGEDGR { ETRGEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & self ) -> ABETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABETRGR { bits } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & self ) -> CPCTRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCTRGR { bits } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & self ) -> LDRAR { LDRAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & self ) -> LDRBR { LDRBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RB Loading" ] # [ inline ] pub fn ldbstop ( & mut self ) -> _LDBSTOPW { _LDBSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RB Loading" ] # [ inline ] pub fn ldbdis ( & mut self ) -> _LDBDISW { _LDBDISW { w : self } } # [ doc = "Bits 8:9 - External Trigger Edge Selection" ] # [ inline ] pub fn etrgedg ( & mut self ) -> _ETRGEDGW { _ETRGEDGW { w : self } } # [ doc = "Bit 10 - TIOA or TIOB External Trigger Selection" ] # [ inline ] pub fn abetrg ( & mut self ) -> _ABETRGW { _ABETRGW { w : self } } # [ doc = "Bit 14 - RC Compare Trigger Enable" ] # [ inline ] pub fn cpctrg ( & mut self ) -> _CPCTRGW { _CPCTRGW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Loading Edge Selection" ] # [ inline ] pub fn ldra ( & mut self ) -> _LDRAW { _LDRAW { w : self } } # [ doc = "Bits 18:19 - RB Loading Edge Selection" ] # [ inline ] pub fn ldrb ( & mut self ) -> _LDRBW { _LDRBW { w : self } } } } # [ doc = "Channel Mode Register (channel = 2)" ] pub struct CMR2_WAVE_EQ_1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Mode Register (channel = 2)" ] pub mod cmr2_wave_eq_1 { # [ 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 :: CMR2_WAVE_EQ_1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TCCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TCCLKSR { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TCCLKSR :: TIMER_CLOCK1 => 0 , TCCLKSR :: TIMER_CLOCK2 => 0x01 , TCCLKSR :: TIMER_CLOCK3 => 0x02 , TCCLKSR :: TIMER_CLOCK4 => 0x03 , TCCLKSR :: TIMER_CLOCK5 => 0x04 , TCCLKSR :: XC0 => 0x05 , TCCLKSR :: XC1 => 0x06 , TCCLKSR :: XC2 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TCCLKSR { match value { 0 => TCCLKSR :: TIMER_CLOCK1 , 1 => TCCLKSR :: TIMER_CLOCK2 , 2 => TCCLKSR :: TIMER_CLOCK3 , 3 => TCCLKSR :: TIMER_CLOCK4 , 4 => TCCLKSR :: TIMER_CLOCK5 , 5 => TCCLKSR :: XC0 , 6 => TCCLKSR :: XC1 , 7 => TCCLKSR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIMER_CLOCK1`" ] # [ inline ] pub fn is_timer_clock1 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK1 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK2`" ] # [ inline ] pub fn is_timer_clock2 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK2 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK3`" ] # [ inline ] pub fn is_timer_clock3 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK3 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK4`" ] # [ inline ] pub fn is_timer_clock4 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK4 } # [ doc = "Checks if the value of the field is `TIMER_CLOCK5`" ] # [ inline ] pub fn is_timer_clock5 ( & self ) -> bool { * self == TCCLKSR :: TIMER_CLOCK5 } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == TCCLKSR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == TCCLKSR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == TCCLKSR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CLKIR { bits : bool , } impl CLKIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `BURST`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BURSTR { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BURSTR :: NONE => 0 , BURSTR :: XC0 => 0x01 , BURSTR :: XC1 => 0x02 , BURSTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BURSTR { match value { 0 => BURSTR :: NONE , 1 => BURSTR :: XC0 , 2 => BURSTR :: XC1 , 3 => BURSTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BURSTR :: NONE } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == BURSTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == BURSTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == BURSTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct CPCSTOPR { bits : bool , } impl CPCSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCDISR { bits : bool , } impl CPCDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EEVTEDG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTEDGR { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTEDGR :: NONE => 0 , EEVTEDGR :: RISING => 0x01 , EEVTEDGR :: FALLING => 0x02 , EEVTEDGR :: EDGE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTEDGR { match value { 0 => EEVTEDGR :: NONE , 1 => EEVTEDGR :: RISING , 2 => EEVTEDGR :: FALLING , 3 => EEVTEDGR :: EDGE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == EEVTEDGR :: NONE } # [ doc = "Checks if the value of the field is `RISING`" ] # [ inline ] pub fn is_rising ( & self ) -> bool { * self == EEVTEDGR :: RISING } # [ doc = "Checks if the value of the field is `FALLING`" ] # [ inline ] pub fn is_falling ( & self ) -> bool { * self == EEVTEDGR :: FALLING } # [ doc = "Checks if the value of the field is `EDGE`" ] # [ inline ] pub fn is_edge ( & self ) -> bool { * self == EEVTEDGR :: EDGE } } # [ doc = "Possible values of the field `EEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EEVTR { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EEVTR :: TIOB => 0 , EEVTR :: XC0 => 0x01 , EEVTR :: XC1 => 0x02 , EEVTR :: XC2 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EEVTR { match value { 0 => EEVTR :: TIOB , 1 => EEVTR :: XC0 , 2 => EEVTR :: XC1 , 3 => EEVTR :: XC2 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `TIOB`" ] # [ inline ] pub fn is_tiob ( & self ) -> bool { * self == EEVTR :: TIOB } # [ doc = "Checks if the value of the field is `XC0`" ] # [ inline ] pub fn is_xc0 ( & self ) -> bool { * self == EEVTR :: XC0 } # [ doc = "Checks if the value of the field is `XC1`" ] # [ inline ] pub fn is_xc1 ( & self ) -> bool { * self == EEVTR :: XC1 } # [ doc = "Checks if the value of the field is `XC2`" ] # [ inline ] pub fn is_xc2 ( & self ) -> bool { * self == EEVTR :: XC2 } } # [ doc = r" Value of the field" ] pub struct ENETRGR { bits : bool , } impl ENETRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WAVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WAVSELR { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WAVSELR :: UP => 0 , WAVSELR :: UPDOWN => 0x01 , WAVSELR :: UP_RC => 0x02 , WAVSELR :: UPDOWN_RC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WAVSELR { match value { 0 => WAVSELR :: UP , 1 => WAVSELR :: UPDOWN , 2 => WAVSELR :: UP_RC , 3 => WAVSELR :: UPDOWN_RC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `UP`" ] # [ inline ] pub fn is_up ( & self ) -> bool { * self == WAVSELR :: UP } # [ doc = "Checks if the value of the field is `UPDOWN`" ] # [ inline ] pub fn is_updown ( & self ) -> bool { * self == WAVSELR :: UPDOWN } # [ doc = "Checks if the value of the field is `UP_RC`" ] # [ inline ] pub fn is_up_rc ( & self ) -> bool { * self == WAVSELR :: UP_RC } # [ doc = "Checks if the value of the field is `UPDOWN_RC`" ] # [ inline ] pub fn is_updown_rc ( & self ) -> bool { * self == WAVSELR :: UPDOWN_RC } } # [ doc = r" Value of the field" ] pub struct WAVER { bits : bool , } impl WAVER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `ACPA`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPAR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPAR :: NONE => 0 , ACPAR :: SET => 0x01 , ACPAR :: CLEAR => 0x02 , ACPAR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPAR { match value { 0 => ACPAR :: NONE , 1 => ACPAR :: SET , 2 => ACPAR :: CLEAR , 3 => ACPAR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPAR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPAR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPAR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPAR :: TOGGLE } } # [ doc = "Possible values of the field `ACPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ACPCR :: NONE => 0 , ACPCR :: SET => 0x01 , ACPCR :: CLEAR => 0x02 , ACPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ACPCR { match value { 0 => ACPCR :: NONE , 1 => ACPCR :: SET , 2 => ACPCR :: CLEAR , 3 => ACPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ACPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ACPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ACPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ACPCR :: TOGGLE } } # [ doc = "Possible values of the field `AEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum AEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { AEEVTR :: NONE => 0 , AEEVTR :: SET => 0x01 , AEEVTR :: CLEAR => 0x02 , AEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> AEEVTR { match value { 0 => AEEVTR :: NONE , 1 => AEEVTR :: SET , 2 => AEEVTR :: CLEAR , 3 => AEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == AEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == AEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == AEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == AEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `ASWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ASWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ASWTRGR :: NONE => 0 , ASWTRGR :: SET => 0x01 , ASWTRGR :: CLEAR => 0x02 , ASWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ASWTRGR { match value { 0 => ASWTRGR :: NONE , 1 => ASWTRGR :: SET , 2 => ASWTRGR :: CLEAR , 3 => ASWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ASWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == ASWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == ASWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == ASWTRGR :: TOGGLE } } # [ doc = "Possible values of the field `BCPB`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPBR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPBR :: NONE => 0 , BCPBR :: SET => 0x01 , BCPBR :: CLEAR => 0x02 , BCPBR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPBR { match value { 0 => BCPBR :: NONE , 1 => BCPBR :: SET , 2 => BCPBR :: CLEAR , 3 => BCPBR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPBR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPBR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPBR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPBR :: TOGGLE } } # [ doc = "Possible values of the field `BCPC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BCPCR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BCPCR :: NONE => 0 , BCPCR :: SET => 0x01 , BCPCR :: CLEAR => 0x02 , BCPCR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BCPCR { match value { 0 => BCPCR :: NONE , 1 => BCPCR :: SET , 2 => BCPCR :: CLEAR , 3 => BCPCR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BCPCR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BCPCR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BCPCR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BCPCR :: TOGGLE } } # [ doc = "Possible values of the field `BEEVT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BEEVTR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BEEVTR :: NONE => 0 , BEEVTR :: SET => 0x01 , BEEVTR :: CLEAR => 0x02 , BEEVTR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BEEVTR { match value { 0 => BEEVTR :: NONE , 1 => BEEVTR :: SET , 2 => BEEVTR :: CLEAR , 3 => BEEVTR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BEEVTR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BEEVTR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BEEVTR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BEEVTR :: TOGGLE } } # [ doc = "Possible values of the field `BSWTRG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BSWTRGR { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { BSWTRGR :: NONE => 0 , BSWTRGR :: SET => 0x01 , BSWTRGR :: CLEAR => 0x02 , BSWTRGR :: TOGGLE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> BSWTRGR { match value { 0 => BSWTRGR :: NONE , 1 => BSWTRGR :: SET , 2 => BSWTRGR :: CLEAR , 3 => BSWTRGR :: TOGGLE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == BSWTRGR :: NONE } # [ doc = "Checks if the value of the field is `SET`" ] # [ inline ] pub fn is_set ( & self ) -> bool { * self == BSWTRGR :: SET } # [ doc = "Checks if the value of the field is `CLEAR`" ] # [ inline ] pub fn is_clear ( & self ) -> bool { * self == BSWTRGR :: CLEAR } # [ doc = "Checks if the value of the field is `TOGGLE`" ] # [ inline ] pub fn is_toggle ( & self ) -> bool { * self == BSWTRGR :: TOGGLE } } # [ doc = "Values that can be written to the field `TCCLKS`" ] pub enum TCCLKSW { # [ doc = "Clock selected: TCLK1" ] TIMER_CLOCK1 , # [ doc = "Clock selected: TCLK2" ] TIMER_CLOCK2 , # [ doc = "Clock selected: TCLK3" ] TIMER_CLOCK3 , # [ doc = "Clock selected: TCLK4" ] TIMER_CLOCK4 , # [ doc = "Clock selected: TCLK5" ] TIMER_CLOCK5 , # [ doc = "Clock selected: XC0" ] XC0 , # [ doc = "Clock selected: XC1" ] XC1 , # [ doc = "Clock selected: XC2" ] XC2 } impl TCCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TCCLKSW :: TIMER_CLOCK1 => 0 , TCCLKSW :: TIMER_CLOCK2 => 1 , TCCLKSW :: TIMER_CLOCK3 => 2 , TCCLKSW :: TIMER_CLOCK4 => 3 , TCCLKSW :: TIMER_CLOCK5 => 4 , TCCLKSW :: XC0 => 5 , TCCLKSW :: XC1 => 6 , TCCLKSW :: XC2 => 7 } } } # [ doc = r" Proxy" ] pub struct _TCCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _TCCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TCCLKSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Clock selected: TCLK1" ] # [ inline ] pub fn timer_clock1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK1 ) } # [ doc = "Clock selected: TCLK2" ] # [ inline ] pub fn timer_clock2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK2 ) } # [ doc = "Clock selected: TCLK3" ] # [ inline ] pub fn timer_clock3 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK3 ) } # [ doc = "Clock selected: TCLK4" ] # [ inline ] pub fn timer_clock4 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK4 ) } # [ doc = "Clock selected: TCLK5" ] # [ inline ] pub fn timer_clock5 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: TIMER_CLOCK5 ) } # [ doc = "Clock selected: XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC0 ) } # [ doc = "Clock selected: XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC1 ) } # [ doc = "Clock selected: XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( TCCLKSW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CLKIW < 'a > { w : & 'a mut W , } impl < 'a > _CLKIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BURST`" ] pub enum BURSTW { # [ doc = "The clock is not gated by an external signal." ] NONE , # [ doc = "XC0 is ANDed with the selected clock." ] XC0 , # [ doc = "XC1 is ANDed with the selected clock." ] XC1 , # [ doc = "XC2 is ANDed with the selected clock." ] XC2 } impl BURSTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BURSTW :: NONE => 0 , BURSTW :: XC0 => 1 , BURSTW :: XC1 => 2 , BURSTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _BURSTW < 'a > { w : & 'a mut W , } impl < 'a > _BURSTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BURSTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The clock is not gated by an external signal." ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BURSTW :: NONE ) } # [ doc = "XC0 is ANDed with the selected clock." ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC0 ) } # [ doc = "XC1 is ANDed with the selected clock." ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC1 ) } # [ doc = "XC2 is ANDed with the selected clock." ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( BURSTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CPCSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSTOPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCDISW < 'a > { w : & 'a mut W , } impl < 'a > _CPCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EEVTEDG`" ] pub enum EEVTEDGW { # [ doc = "None" ] NONE , # [ doc = "Rising edge" ] RISING , # [ doc = "Falling edge" ] FALLING , # [ doc = "Each edge" ] EDGE } impl EEVTEDGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTEDGW :: NONE => 0 , EEVTEDGW :: RISING => 1 , EEVTEDGW :: FALLING => 2 , EEVTEDGW :: EDGE => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTEDGW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTEDGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTEDGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: NONE ) } # [ doc = "Rising edge" ] # [ inline ] pub fn rising ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: RISING ) } # [ doc = "Falling edge" ] # [ inline ] pub fn falling ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: FALLING ) } # [ doc = "Each edge" ] # [ inline ] pub fn edge ( self ) -> & 'a mut W { self . variant ( EEVTEDGW :: EDGE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EEVT`" ] pub enum EEVTW { # [ doc = "TIOB" ] TIOB , # [ doc = "XC0" ] XC0 , # [ doc = "XC1" ] XC1 , # [ doc = "XC2" ] XC2 } impl EEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EEVTW :: TIOB => 0 , EEVTW :: XC0 => 1 , EEVTW :: XC1 => 2 , EEVTW :: XC2 => 3 } } } # [ doc = r" Proxy" ] pub struct _EEVTW < 'a > { w : & 'a mut W , } impl < 'a > _EEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "TIOB" ] # [ inline ] pub fn tiob ( self ) -> & 'a mut W { self . variant ( EEVTW :: TIOB ) } # [ doc = "XC0" ] # [ inline ] pub fn xc0 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC0 ) } # [ doc = "XC1" ] # [ inline ] pub fn xc1 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC1 ) } # [ doc = "XC2" ] # [ inline ] pub fn xc2 ( self ) -> & 'a mut W { self . variant ( EEVTW :: XC2 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _ENETRGW < 'a > { w : & 'a mut W , } impl < 'a > _ENETRGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WAVSEL`" ] pub enum WAVSELW { # [ doc = "UP mode without automatic trigger on RC Compare" ] UP , # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] UPDOWN , # [ doc = "UP mode with automatic trigger on RC Compare" ] UP_RC , # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] UPDOWN_RC } impl WAVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WAVSELW :: UP => 0 , WAVSELW :: UPDOWN => 1 , WAVSELW :: UP_RC => 2 , WAVSELW :: UPDOWN_RC => 3 } } } # [ doc = r" Proxy" ] pub struct _WAVSELW < 'a > { w : & 'a mut W , } impl < 'a > _WAVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WAVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "UP mode without automatic trigger on RC Compare" ] # [ inline ] pub fn up ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP ) } # [ doc = "UPDOWN mode without automatic trigger on RC Compare" ] # [ inline ] pub fn updown ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN ) } # [ doc = "UP mode with automatic trigger on RC Compare" ] # [ inline ] pub fn up_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UP_RC ) } # [ doc = "UPDOWN mode with automatic trigger on RC Compare" ] # [ inline ] pub fn updown_rc ( self ) -> & 'a mut W { self . variant ( WAVSELW :: UPDOWN_RC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WAVEW < 'a > { w : & 'a mut W , } impl < 'a > _WAVEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `ACPA`" ] pub enum ACPAW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPAW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPAW :: NONE => 0 , ACPAW :: SET => 1 , ACPAW :: CLEAR => 2 , ACPAW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPAW < 'a > { w : & 'a mut W , } impl < 'a > _ACPAW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPAW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPAW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPAW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPAW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPAW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ACPC`" ] pub enum ACPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ACPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ACPCW :: NONE => 0 , ACPCW :: SET => 1 , ACPCW :: CLEAR => 2 , ACPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ACPCW < 'a > { w : & 'a mut W , } impl < 'a > _ACPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ACPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ACPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ACPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ACPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ACPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `AEEVT`" ] pub enum AEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl AEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { AEEVTW :: NONE => 0 , AEEVTW :: SET => 1 , AEEVTW :: CLEAR => 2 , AEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _AEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _AEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : AEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( AEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( AEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( AEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( AEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ASWTRG`" ] pub enum ASWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl ASWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ASWTRGW :: NONE => 0 , ASWTRGW :: SET => 1 , ASWTRGW :: CLEAR => 2 , ASWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _ASWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _ASWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ASWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( ASWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPB`" ] pub enum BCPBW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPBW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPBW :: NONE => 0 , BCPBW :: SET => 1 , BCPBW :: CLEAR => 2 , BCPBW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPBW < 'a > { w : & 'a mut W , } impl < 'a > _BCPBW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPBW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPBW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPBW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPBW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPBW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BCPC`" ] pub enum BCPCW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BCPCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BCPCW :: NONE => 0 , BCPCW :: SET => 1 , BCPCW :: CLEAR => 2 , BCPCW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BCPCW < 'a > { w : & 'a mut W , } impl < 'a > _BCPCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BCPCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BCPCW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BCPCW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BCPCW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BCPCW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BEEVT`" ] pub enum BEEVTW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BEEVTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BEEVTW :: NONE => 0 , BEEVTW :: SET => 1 , BEEVTW :: CLEAR => 2 , BEEVTW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BEEVTW < 'a > { w : & 'a mut W , } impl < 'a > _BEEVTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BEEVTW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BEEVTW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BEEVTW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BEEVTW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BEEVTW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `BSWTRG`" ] pub enum BSWTRGW { # [ doc = "None" ] NONE , # [ doc = "Set" ] SET , # [ doc = "Clear" ] CLEAR , # [ doc = "Toggle" ] TOGGLE } impl BSWTRGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { BSWTRGW :: NONE => 0 , BSWTRGW :: SET => 1 , BSWTRGW :: CLEAR => 2 , BSWTRGW :: TOGGLE => 3 } } } # [ doc = r" Proxy" ] pub struct _BSWTRGW < 'a > { w : & 'a mut W , } impl < 'a > _BSWTRGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BSWTRGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "None" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: NONE ) } # [ doc = "Set" ] # [ inline ] pub fn set ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: SET ) } # [ doc = "Clear" ] # [ inline ] pub fn clear ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: CLEAR ) } # [ doc = "Toggle" ] # [ inline ] pub fn toggle ( self ) -> & 'a mut W { self . variant ( BSWTRGW :: TOGGLE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Clock Selection" ] # [ inline ] pub fn tcclks ( & self ) -> TCCLKSR { TCCLKSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & self ) -> CLKIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKIR { bits } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & self ) -> BURSTR { BURSTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & self ) -> CPCSTOPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSTOPR { bits } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & self ) -> CPCDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCDISR { bits } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & self ) -> EEVTEDGR { EEVTEDGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & self ) -> EEVTR { EEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & self ) -> ENETRGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENETRGR { bits } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & self ) -> WAVSELR { WAVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & self ) -> WAVER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAVER { bits } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & self ) -> ACPAR { ACPAR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & self ) -> ACPCR { ACPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & self ) -> AEEVTR { AEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & self ) -> ASWTRGR { ASWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & self ) -> BCPBR { BCPBR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & self ) -> BCPCR { BCPCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & self ) -> BEEVTR { BEEVTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & self ) -> BSWTRGR { BSWTRGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Clock Selection" ] # [ inline ] pub fn tcclks ( & mut self ) -> _TCCLKSW { _TCCLKSW { w : self } } # [ doc = "Bit 3 - Clock Invert" ] # [ inline ] pub fn clki ( & mut self ) -> _CLKIW { _CLKIW { w : self } } # [ doc = "Bits 4:5 - Burst Signal Selection" ] # [ inline ] pub fn burst ( & mut self ) -> _BURSTW { _BURSTW { w : self } } # [ doc = "Bit 6 - Counter Clock Stopped with RC Compare" ] # [ inline ] pub fn cpcstop ( & mut self ) -> _CPCSTOPW { _CPCSTOPW { w : self } } # [ doc = "Bit 7 - Counter Clock Disable with RC Compare" ] # [ inline ] pub fn cpcdis ( & mut self ) -> _CPCDISW { _CPCDISW { w : self } } # [ doc = "Bits 8:9 - External Event Edge Selection" ] # [ inline ] pub fn eevtedg ( & mut self ) -> _EEVTEDGW { _EEVTEDGW { w : self } } # [ doc = "Bits 10:11 - External Event Selection" ] # [ inline ] pub fn eevt ( & mut self ) -> _EEVTW { _EEVTW { w : self } } # [ doc = "Bit 12 - External Event Trigger Enable" ] # [ inline ] pub fn enetrg ( & mut self ) -> _ENETRGW { _ENETRGW { w : self } } # [ doc = "Bits 13:14 - Waveform Selection" ] # [ inline ] pub fn wavsel ( & mut self ) -> _WAVSELW { _WAVSELW { w : self } } # [ doc = "Bit 15 - Waveform Mode" ] # [ inline ] pub fn wave ( & mut self ) -> _WAVEW { _WAVEW { w : self } } # [ doc = "Bits 16:17 - RA Compare Effect on TIOA" ] # [ inline ] pub fn acpa ( & mut self ) -> _ACPAW { _ACPAW { w : self } } # [ doc = "Bits 18:19 - RC Compare Effect on TIOA" ] # [ inline ] pub fn acpc ( & mut self ) -> _ACPCW { _ACPCW { w : self } } # [ doc = "Bits 20:21 - External Event Effect on TIOA" ] # [ inline ] pub fn aeevt ( & mut self ) -> _AEEVTW { _AEEVTW { w : self } } # [ doc = "Bits 22:23 - Software Trigger Effect on TIOA" ] # [ inline ] pub fn aswtrg ( & mut self ) -> _ASWTRGW { _ASWTRGW { w : self } } # [ doc = "Bits 24:25 - RB Compare Effect on TIOB" ] # [ inline ] pub fn bcpb ( & mut self ) -> _BCPBW { _BCPBW { w : self } } # [ doc = "Bits 26:27 - RC Compare Effect on TIOB" ] # [ inline ] pub fn bcpc ( & mut self ) -> _BCPCW { _BCPCW { w : self } } # [ doc = "Bits 28:29 - External Event Effect on TIOB" ] # [ inline ] pub fn beevt ( & mut self ) -> _BEEVTW { _BEEVTW { w : self } } # [ doc = "Bits 30:31 - Software Trigger Effect on TIOB" ] # [ inline ] pub fn bswtrg ( & mut self ) -> _BSWTRGW { _BSWTRGW { w : self } } } } # [ doc = "Stepper Motor Mode Register (channel = 2)" ] pub struct SMMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Stepper Motor Mode Register (channel = 2)" ] pub mod smmr2 { # [ 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 :: SMMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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 DOWNR { bits : bool , } impl DOWNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DOWNW < 'a > { w : & 'a mut W , } impl < 'a > _DOWNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & self ) -> GCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCENR { bits } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & self ) -> DOWNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWNR { 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 - Gray Count Enable" ] # [ inline ] pub fn gcen ( & mut self ) -> _GCENW { _GCENW { w : self } } # [ doc = "Bit 1 - DOWN Count" ] # [ inline ] pub fn down ( & mut self ) -> _DOWNW { _DOWNW { w : self } } } } # [ doc = "Counter Value (channel = 2)" ] pub struct CV2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Counter Value (channel = 2)" ] pub mod cv2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CV2 { # [ 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 CVR { bits : u32 , } impl CVR { # [ 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 - Counter Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } } } # [ doc = "Register A (channel = 2)" ] pub struct RA2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register A (channel = 2)" ] pub mod ra2 { # [ 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 :: RA2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RAR { bits : u32 , } impl RAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RAW < 'a > { w : & 'a mut W , } impl < 'a > _RAW < '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 - Register A" ] # [ inline ] pub fn ra ( & self ) -> RAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RAR { 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 - Register A" ] # [ inline ] pub fn ra ( & mut self ) -> _RAW { _RAW { w : self } } } } # [ doc = "Register B (channel = 2)" ] pub struct RB2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register B (channel = 2)" ] pub mod rb2 { # [ 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 :: RB2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RBR { bits : u32 , } impl RBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RBW < 'a > { w : & 'a mut W , } impl < 'a > _RBW < '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 - Register B" ] # [ inline ] pub fn rb ( & self ) -> RBR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RBR { 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 - Register B" ] # [ inline ] pub fn rb ( & mut self ) -> _RBW { _RBW { w : self } } } } # [ doc = "Register C (channel = 2)" ] pub struct RC2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Register C (channel = 2)" ] pub mod rc2 { # [ 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 :: RC2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCR { bits : u32 , } impl RCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RCW < 'a > { w : & 'a mut W , } impl < 'a > _RCW < '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 - Register C" ] # [ inline ] pub fn rc ( & self ) -> RCR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RCR { 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 - Register C" ] # [ inline ] pub fn rc ( & mut self ) -> _RCW { _RCW { w : self } } } } # [ doc = "Status Register (channel = 2)" ] pub struct SR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register (channel = 2)" ] pub mod sr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: SR2 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKSTAR { bits : bool , } impl CLKSTAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOAR { bits : bool , } impl MTIOAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIOBR { bits : bool , } impl MTIOBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow Status" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun Status" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare Status" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare Status" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare Status" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading Status" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading Status" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger Status" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } # [ doc = "Bit 16 - Clock Enabling Status" ] # [ inline ] pub fn clksta ( & self ) -> CLKSTAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKSTAR { bits } } # [ doc = "Bit 17 - TIOA Mirror" ] # [ inline ] pub fn mtioa ( & self ) -> MTIOAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOAR { bits } } # [ doc = "Bit 18 - TIOB Mirror" ] # [ inline ] pub fn mtiob ( & self ) -> MTIOBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIOBR { bits } } } } # [ doc = "Interrupt Enable Register (channel = 2)" ] pub struct IER2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register (channel = 2)" ] pub mod ier2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Disable Register (channel = 2)" ] pub struct IDR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register (channel = 2)" ] pub mod idr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _COVFSW < 'a > { w : & 'a mut W , } impl < 'a > _COVFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOVRSW < 'a > { w : & 'a mut W , } impl < 'a > _LOVRSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPASW < 'a > { w : & 'a mut W , } impl < 'a > _CPASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPBSW < 'a > { w : & 'a mut W , } impl < 'a > _CPBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CPCSW < 'a > { w : & 'a mut W , } impl < 'a > _CPCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRASW < 'a > { w : & 'a mut W , } impl < 'a > _LDRASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDRBSW < 'a > { w : & 'a mut W , } impl < 'a > _LDRBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ETRGSW < 'a > { w : & 'a mut W , } impl < 'a > _ETRGSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Overflow" ] # [ inline ] pub fn covfs ( & mut self ) -> _COVFSW { _COVFSW { w : self } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & mut self ) -> _LOVRSW { _LOVRSW { w : self } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & mut self ) -> _CPASW { _CPASW { w : self } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & mut self ) -> _CPBSW { _CPBSW { w : self } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & mut self ) -> _CPCSW { _CPCSW { w : self } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & mut self ) -> _LDRASW { _LDRASW { w : self } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & mut self ) -> _LDRBSW { _LDRBSW { w : self } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & mut self ) -> _ETRGSW { _ETRGSW { w : self } } } } # [ doc = "Interrupt Mask Register (channel = 2)" ] pub struct IMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register (channel = 2)" ] pub mod imr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR2 { # [ 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 COVFSR { bits : bool , } impl COVFSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOVRSR { bits : bool , } impl LOVRSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPASR { bits : bool , } impl CPASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPBSR { bits : bool , } impl CPBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CPCSR { bits : bool , } impl CPCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRASR { bits : bool , } impl LDRASR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDRBSR { bits : bool , } impl LDRBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ETRGSR { bits : bool , } impl ETRGSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Overflow" ] # [ inline ] pub fn covfs ( & self ) -> COVFSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COVFSR { bits } } # [ doc = "Bit 1 - Load Overrun" ] # [ inline ] pub fn lovrs ( & self ) -> LOVRSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOVRSR { bits } } # [ doc = "Bit 2 - RA Compare" ] # [ inline ] pub fn cpas ( & self ) -> CPASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPASR { bits } } # [ doc = "Bit 3 - RB Compare" ] # [ inline ] pub fn cpbs ( & self ) -> CPBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPBSR { bits } } # [ doc = "Bit 4 - RC Compare" ] # [ inline ] pub fn cpcs ( & self ) -> CPCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPCSR { bits } } # [ doc = "Bit 5 - RA Loading" ] # [ inline ] pub fn ldras ( & self ) -> LDRASR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRASR { bits } } # [ doc = "Bit 6 - RB Loading" ] # [ inline ] pub fn ldrbs ( & self ) -> LDRBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDRBSR { bits } } # [ doc = "Bit 7 - External Trigger" ] # [ inline ] pub fn etrgs ( & self ) -> ETRGSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ETRGSR { bits } } } } # [ doc = "Block Control Register" ] pub struct BCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Block Control Register" ] pub mod bcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: BCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Synchro Command" ] # [ inline ] pub fn sync ( & mut self ) -> _SYNCW { _SYNCW { w : self } } } } # [ doc = "Block Mode Register" ] pub struct BMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Block Mode Register" ] pub mod bmr { # [ 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 :: BMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TC0XC0S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC0XC0SR { # [ doc = "Signal connected to XC0: TCLK0" ] TCLK0 , # [ doc = "Signal connected to XC0: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC0: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC0XC0SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC0XC0SR :: TCLK0 => 0 , TC0XC0SR :: TIOA1 => 0x02 , TC0XC0SR :: TIOA2 => 0x03 , TC0XC0SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC0XC0SR { match value { 0 => TC0XC0SR :: TCLK0 , 2 => TC0XC0SR :: TIOA1 , 3 => TC0XC0SR :: TIOA2 , i => TC0XC0SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK0`" ] # [ inline ] pub fn is_tclk0 ( & self ) -> bool { * self == TC0XC0SR :: TCLK0 } # [ doc = "Checks if the value of the field is `TIOA1`" ] # [ inline ] pub fn is_tioa1 ( & self ) -> bool { * self == TC0XC0SR :: TIOA1 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC0XC0SR :: TIOA2 } } # [ doc = "Possible values of the field `TC1XC1S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC1XC1SR { # [ doc = "Signal connected to XC1: TCLK1" ] TCLK1 , # [ doc = "Signal connected to XC1: TIOA0" ] TIOA0 , # [ doc = "Signal connected to XC1: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC1XC1SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC1XC1SR :: TCLK1 => 0 , TC1XC1SR :: TIOA0 => 0x02 , TC1XC1SR :: TIOA2 => 0x03 , TC1XC1SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC1XC1SR { match value { 0 => TC1XC1SR :: TCLK1 , 2 => TC1XC1SR :: TIOA0 , 3 => TC1XC1SR :: TIOA2 , i => TC1XC1SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK1`" ] # [ inline ] pub fn is_tclk1 ( & self ) -> bool { * self == TC1XC1SR :: TCLK1 } # [ doc = "Checks if the value of the field is `TIOA0`" ] # [ inline ] pub fn is_tioa0 ( & self ) -> bool { * self == TC1XC1SR :: TIOA0 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC1XC1SR :: TIOA2 } } # [ doc = "Possible values of the field `TC2XC2S`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TC2XC2SR { # [ doc = "Signal connected to XC2: TCLK2" ] TCLK2 , # [ doc = "Signal connected to XC2: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC2: TIOA2" ] TIOA2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TC2XC2SR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TC2XC2SR :: TCLK2 => 0 , TC2XC2SR :: TIOA1 => 0x02 , TC2XC2SR :: TIOA2 => 0x03 , TC2XC2SR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TC2XC2SR { match value { 0 => TC2XC2SR :: TCLK2 , 2 => TC2XC2SR :: TIOA1 , 3 => TC2XC2SR :: TIOA2 , i => TC2XC2SR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `TCLK2`" ] # [ inline ] pub fn is_tclk2 ( & self ) -> bool { * self == TC2XC2SR :: TCLK2 } # [ doc = "Checks if the value of the field is `TIOA1`" ] # [ inline ] pub fn is_tioa1 ( & self ) -> bool { * self == TC2XC2SR :: TIOA1 } # [ doc = "Checks if the value of the field is `TIOA2`" ] # [ inline ] pub fn is_tioa2 ( & self ) -> bool { * self == TC2XC2SR :: TIOA2 } } # [ doc = r" Value of the field" ] pub struct QDENR { bits : bool , } impl QDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct POSENR { bits : bool , } impl POSENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SPEEDENR { bits : bool , } impl SPEEDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QDTRANSR { bits : bool , } impl QDTRANSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EDGPHAR { bits : bool , } impl EDGPHAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVAR { bits : bool , } impl INVAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVBR { bits : bool , } impl INVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVIDXR { bits : bool , } impl INVIDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 IDXPHBR { bits : bool , } impl IDXPHBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FILTERR { bits : bool , } impl FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MAXFILTR { bits : u8 , } impl MAXFILTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Values that can be written to the field `TC0XC0S`" ] pub enum TC0XC0SW { # [ doc = "Signal connected to XC0: TCLK0" ] TCLK0 , # [ doc = "Signal connected to XC0: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC0: TIOA2" ] TIOA2 } impl TC0XC0SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC0XC0SW :: TCLK0 => 0 , TC0XC0SW :: TIOA1 => 2 , TC0XC0SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC0XC0SW < 'a > { w : & 'a mut W , } impl < 'a > _TC0XC0SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC0XC0SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC0: TCLK0" ] # [ inline ] pub fn tclk0 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TCLK0 ) } # [ doc = "Signal connected to XC0: TIOA1" ] # [ inline ] pub fn tioa1 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TIOA1 ) } # [ doc = "Signal connected to XC0: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC0XC0SW :: TIOA2 ) } # [ 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 = "Values that can be written to the field `TC1XC1S`" ] pub enum TC1XC1SW { # [ doc = "Signal connected to XC1: TCLK1" ] TCLK1 , # [ doc = "Signal connected to XC1: TIOA0" ] TIOA0 , # [ doc = "Signal connected to XC1: TIOA2" ] TIOA2 } impl TC1XC1SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC1XC1SW :: TCLK1 => 0 , TC1XC1SW :: TIOA0 => 2 , TC1XC1SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC1XC1SW < 'a > { w : & 'a mut W , } impl < 'a > _TC1XC1SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC1XC1SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC1: TCLK1" ] # [ inline ] pub fn tclk1 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TCLK1 ) } # [ doc = "Signal connected to XC1: TIOA0" ] # [ inline ] pub fn tioa0 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TIOA0 ) } # [ doc = "Signal connected to XC1: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC1XC1SW :: TIOA2 ) } # [ 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 = "Values that can be written to the field `TC2XC2S`" ] pub enum TC2XC2SW { # [ doc = "Signal connected to XC2: TCLK2" ] TCLK2 , # [ doc = "Signal connected to XC2: TIOA1" ] TIOA1 , # [ doc = "Signal connected to XC2: TIOA2" ] TIOA2 } impl TC2XC2SW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TC2XC2SW :: TCLK2 => 0 , TC2XC2SW :: TIOA1 => 2 , TC2XC2SW :: TIOA2 => 3 } } } # [ doc = r" Proxy" ] pub struct _TC2XC2SW < 'a > { w : & 'a mut W , } impl < 'a > _TC2XC2SW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TC2XC2SW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Signal connected to XC2: TCLK2" ] # [ inline ] pub fn tclk2 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TCLK2 ) } # [ doc = "Signal connected to XC2: TIOA1" ] # [ inline ] pub fn tioa1 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TIOA1 ) } # [ doc = "Signal connected to XC2: TIOA2" ] # [ inline ] pub fn tioa2 ( self ) -> & 'a mut W { self . variant ( TC2XC2SW :: TIOA2 ) } # [ 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 _QDENW < 'a > { w : & 'a mut W , } impl < 'a > _QDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _POSENW < 'a > { w : & 'a mut W , } impl < 'a > _POSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SPEEDENW < 'a > { w : & 'a mut W , } impl < 'a > _SPEEDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QDTRANSW < 'a > { w : & 'a mut W , } impl < 'a > _QDTRANSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EDGPHAW < 'a > { w : & 'a mut W , } impl < 'a > _EDGPHAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVAW < 'a > { w : & 'a mut W , } impl < 'a > _INVAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVBW < 'a > { w : & 'a mut W , } impl < 'a > _INVBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVIDXW < 'a > { w : & 'a mut W , } impl < 'a > _INVIDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _IDXPHBW < 'a > { w : & 'a mut W , } impl < 'a > _IDXPHBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _FILTERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MAXFILTW < 'a > { w : & 'a mut W , } impl < 'a > _MAXFILTW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; const OFFSET : u8 = 20 ; 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 - External Clock Signal 0 Selection" ] # [ inline ] pub fn tc0xc0s ( & self ) -> TC0XC0SR { TC0XC0SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 2:3 - External Clock Signal 1 Selection" ] # [ inline ] pub fn tc1xc1s ( & self ) -> TC1XC1SR { TC1XC1SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - External Clock Signal 2 Selection" ] # [ inline ] pub fn tc2xc2s ( & self ) -> TC2XC2SR { TC2XC2SR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Quadrature Decoder ENabled" ] # [ inline ] pub fn qden ( & self ) -> QDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QDENR { bits } } # [ doc = "Bit 9 - POSition ENabled" ] # [ inline ] pub fn posen ( & self ) -> POSENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; POSENR { bits } } # [ doc = "Bit 10 - SPEED ENabled" ] # [ inline ] pub fn speeden ( & self ) -> SPEEDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SPEEDENR { bits } } # [ doc = "Bit 11 - Quadrature Decoding TRANSparent" ] # [ inline ] pub fn qdtrans ( & self ) -> QDTRANSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QDTRANSR { bits } } # [ doc = "Bit 12 - EDGe on PHA count mode" ] # [ inline ] pub fn edgpha ( & self ) -> EDGPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EDGPHAR { bits } } # [ doc = "Bit 13 - INVerted phA" ] # [ inline ] pub fn inva ( & self ) -> INVAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVAR { bits } } # [ doc = "Bit 14 - INVerted phB" ] # [ inline ] pub fn invb ( & self ) -> INVBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVBR { bits } } # [ doc = "Bit 15 - INVerted InDeX" ] # [ inline ] pub fn invidx ( & self ) -> INVIDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVIDXR { bits } } # [ doc = "Bit 16 - SWAP PHA and PHB" ] # [ inline ] pub fn swap ( & self ) -> SWAPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SWAPR { bits } } # [ doc = "Bit 17 - InDeX pin is PHB pin" ] # [ inline ] pub fn idxphb ( & self ) -> IDXPHBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXPHBR { bits } } # [ doc = "Bit 19" ] # [ inline ] pub fn filter ( & self ) -> FILTERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FILTERR { bits } } # [ doc = "Bits 20:25 - MAXimum FILTer" ] # [ inline ] pub fn maxfilt ( & self ) -> MAXFILTR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MAXFILTR { 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 - External Clock Signal 0 Selection" ] # [ inline ] pub fn tc0xc0s ( & mut self ) -> _TC0XC0SW { _TC0XC0SW { w : self } } # [ doc = "Bits 2:3 - External Clock Signal 1 Selection" ] # [ inline ] pub fn tc1xc1s ( & mut self ) -> _TC1XC1SW { _TC1XC1SW { w : self } } # [ doc = "Bits 4:5 - External Clock Signal 2 Selection" ] # [ inline ] pub fn tc2xc2s ( & mut self ) -> _TC2XC2SW { _TC2XC2SW { w : self } } # [ doc = "Bit 8 - Quadrature Decoder ENabled" ] # [ inline ] pub fn qden ( & mut self ) -> _QDENW { _QDENW { w : self } } # [ doc = "Bit 9 - POSition ENabled" ] # [ inline ] pub fn posen ( & mut self ) -> _POSENW { _POSENW { w : self } } # [ doc = "Bit 10 - SPEED ENabled" ] # [ inline ] pub fn speeden ( & mut self ) -> _SPEEDENW { _SPEEDENW { w : self } } # [ doc = "Bit 11 - Quadrature Decoding TRANSparent" ] # [ inline ] pub fn qdtrans ( & mut self ) -> _QDTRANSW { _QDTRANSW { w : self } } # [ doc = "Bit 12 - EDGe on PHA count mode" ] # [ inline ] pub fn edgpha ( & mut self ) -> _EDGPHAW { _EDGPHAW { w : self } } # [ doc = "Bit 13 - INVerted phA" ] # [ inline ] pub fn inva ( & mut self ) -> _INVAW { _INVAW { w : self } } # [ doc = "Bit 14 - INVerted phB" ] # [ inline ] pub fn invb ( & mut self ) -> _INVBW { _INVBW { w : self } } # [ doc = "Bit 15 - INVerted InDeX" ] # [ inline ] pub fn invidx ( & mut self ) -> _INVIDXW { _INVIDXW { w : self } } # [ doc = "Bit 16 - SWAP PHA and PHB" ] # [ inline ] pub fn swap ( & mut self ) -> _SWAPW { _SWAPW { w : self } } # [ doc = "Bit 17 - InDeX pin is PHB pin" ] # [ inline ] pub fn idxphb ( & mut self ) -> _IDXPHBW { _IDXPHBW { w : self } } # [ doc = "Bit 19" ] # [ inline ] pub fn filter ( & mut self ) -> _FILTERW { _FILTERW { w : self } } # [ doc = "Bits 20:25 - MAXimum FILTer" ] # [ inline ] pub fn maxfilt ( & mut self ) -> _MAXFILTW { _MAXFILTW { w : self } } } } # [ doc = "QDEC Interrupt Enable Register" ] pub struct QIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Enable Register" ] pub mod qier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: QIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDXW < 'a > { w : & 'a mut W , } impl < 'a > _IDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIRCHGW < 'a > { w : & 'a mut W , } impl < 'a > _DIRCHGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QERRW < 'a > { w : & 'a mut W , } impl < 'a > _QERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & mut self ) -> _IDXW { _IDXW { w : self } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & mut self ) -> _DIRCHGW { _DIRCHGW { w : self } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & mut self ) -> _QERRW { _QERRW { w : self } } } } # [ doc = "QDEC Interrupt Disable Register" ] pub struct QIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Disable Register" ] pub mod qidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: QIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDXW < 'a > { w : & 'a mut W , } impl < 'a > _IDXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIRCHGW < 'a > { w : & 'a mut W , } impl < 'a > _DIRCHGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QERRW < 'a > { w : & 'a mut W , } impl < 'a > _QERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & mut self ) -> _IDXW { _IDXW { w : self } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & mut self ) -> _DIRCHGW { _DIRCHGW { w : self } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & mut self ) -> _QERRW { _QERRW { w : self } } } } # [ doc = "QDEC Interrupt Mask Register" ] pub struct QIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Mask Register" ] pub mod qimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: QIMR { # [ 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 IDXR { bits : bool , } impl IDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIRCHGR { bits : bool , } impl DIRCHGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QERRR { bits : bool , } impl QERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - InDeX" ] # [ inline ] pub fn idx ( & self ) -> IDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXR { bits } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & self ) -> DIRCHGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRCHGR { bits } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & self ) -> QERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QERRR { bits } } } } # [ doc = "QDEC Interrupt Status Register" ] pub struct QISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "QDEC Interrupt Status Register" ] pub mod qisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: QISR { # [ 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 IDXR { bits : bool , } impl IDXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIRCHGR { bits : bool , } impl DIRCHGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct QERRR { bits : bool , } impl QERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ( ) } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - InDeX" ] # [ inline ] pub fn idx ( & self ) -> IDXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDXR { bits } } # [ doc = "Bit 1 - DIRection CHanGe" ] # [ inline ] pub fn dirchg ( & self ) -> DIRCHGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRCHGR { bits } } # [ doc = "Bit 2 - Quadrature ERRor" ] # [ inline ] pub fn qerr ( & self ) -> QERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; QERRR { bits } } # [ doc = "Bit 8 - DIRection" ] # [ inline ] pub fn dir ( & self ) -> DIRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIRR { bits } } } } # [ doc = "Fault Mode Register" ] pub struct FMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fault Mode Register" ] pub mod fmr { # [ 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 :: FMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ENCF0R { bits : bool , } impl ENCF0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENCF1R { bits : bool , } impl ENCF1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _ENCF0W < 'a > { w : & 'a mut W , } impl < 'a > _ENCF0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENCF1W < 'a > { w : & 'a mut W , } impl < 'a > _ENCF1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - ENable Compare Fault Channel 0" ] # [ inline ] pub fn encf0 ( & self ) -> ENCF0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENCF0R { bits } } # [ doc = "Bit 1 - ENable Compare Fault Channel 1" ] # [ inline ] pub fn encf1 ( & self ) -> ENCF1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENCF1R { 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 - ENable Compare Fault Channel 0" ] # [ inline ] pub fn encf0 ( & mut self ) -> _ENCF0W { _ENCF0W { w : self } } # [ doc = "Bit 1 - ENable Compare Fault Channel 1" ] # [ inline ] pub fn encf1 ( & mut self ) -> _ENCF1W { _ENCF1W { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0054_494d , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5523789 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5523789 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } } # [ doc = "Two-wire Interface 0" ] pub struct TWI0 { _marker : PhantomData < * const ( ) > } unsafe impl Send for TWI0 { } impl TWI0 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const twi0 :: RegisterBlock { 0x4008_c000 as * const _ } } impl Deref for TWI0 { type Target = twi0 :: RegisterBlock ; fn deref ( & self ) -> & twi0 :: RegisterBlock { unsafe { & * TWI0 :: ptr ( ) } } } # [ doc = "Two-wire Interface 0" ] pub mod twi0 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Master Mode Register" ] pub mmr : MMR , # [ doc = "0x08 - Slave Mode Register" ] pub smr : SMR , # [ doc = "0x0c - Internal Address Register" ] pub iadr : IADR , # [ doc = "0x10 - Clock Waveform Generator Register" ] pub cwgr : CWGR , _reserved5 : [ u8 ; 12usize ] , # [ doc = "0x20 - Status Register" ] pub sr : SR , # [ doc = "0x24 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x28 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x2c - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x30 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x34 - Transmit Holding Register" ] pub thr : THR , _reserved11 : [ u8 ; 200usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; 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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _MSENW < 'a > { w : & 'a mut W , } impl < 'a > _MSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSDISW < 'a > { w : & 'a mut W , } impl < 'a > _MSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVENW < 'a > { w : & 'a mut W , } impl < 'a > _SVENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVDISW < 'a > { w : & 'a mut W , } impl < 'a > _SVDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QUICKW < 'a > { w : & 'a mut W , } impl < 'a > _QUICKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 7 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bit 0 - Send a START Condition" ] # [ inline ] pub fn start ( & mut self ) -> _STARTW { _STARTW { w : self } } # [ doc = "Bit 1 - Send a STOP Condition" ] # [ inline ] pub fn stop ( & mut self ) -> _STOPW { _STOPW { w : self } } # [ doc = "Bit 2 - TWI Master Mode Enabled" ] # [ inline ] pub fn msen ( & mut self ) -> _MSENW { _MSENW { w : self } } # [ doc = "Bit 3 - TWI Master Mode Disabled" ] # [ inline ] pub fn msdis ( & mut self ) -> _MSDISW { _MSDISW { w : self } } # [ doc = "Bit 4 - TWI Slave Mode Enabled" ] # [ inline ] pub fn sven ( & mut self ) -> _SVENW { _SVENW { w : self } } # [ doc = "Bit 5 - TWI Slave Mode Disabled" ] # [ inline ] pub fn svdis ( & mut self ) -> _SVDISW { _SVDISW { w : self } } # [ doc = "Bit 6 - SMBUS Quick Command" ] # [ inline ] pub fn quick ( & mut self ) -> _QUICKW { _QUICKW { w : self } } # [ doc = "Bit 7 - Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } } } # [ doc = "Master Mode Register" ] pub struct MMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Master Mode Register" ] pub mod mmr { # [ 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 :: MMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `IADRSZ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum IADRSZR { # [ doc = "No internal device address" ] NONE , # [ doc = "One-byte internal device address" ] _1_BYTE , # [ doc = "Two-byte internal device address" ] _2_BYTE , # [ doc = "Three-byte internal device address" ] _3_BYTE } impl IADRSZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { IADRSZR :: NONE => 0 , IADRSZR :: _1_BYTE => 0x01 , IADRSZR :: _2_BYTE => 0x02 , IADRSZR :: _3_BYTE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> IADRSZR { match value { 0 => IADRSZR :: NONE , 1 => IADRSZR :: _1_BYTE , 2 => IADRSZR :: _2_BYTE , 3 => IADRSZR :: _3_BYTE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == IADRSZR :: NONE } # [ doc = "Checks if the value of the field is `_1_BYTE`" ] # [ inline ] pub fn is_1_byte ( & self ) -> bool { * self == IADRSZR :: _1_BYTE } # [ doc = "Checks if the value of the field is `_2_BYTE`" ] # [ inline ] pub fn is_2_byte ( & self ) -> bool { * self == IADRSZR :: _2_BYTE } # [ doc = "Checks if the value of the field is `_3_BYTE`" ] # [ inline ] pub fn is_3_byte ( & self ) -> bool { * self == IADRSZR :: _3_BYTE } } # [ doc = r" Value of the field" ] pub struct MREADR { bits : bool , } impl MREADR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DADRR { bits : u8 , } impl DADRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Values that can be written to the field `IADRSZ`" ] pub enum IADRSZW { # [ doc = "No internal device address" ] NONE , # [ doc = "One-byte internal device address" ] _1_BYTE , # [ doc = "Two-byte internal device address" ] _2_BYTE , # [ doc = "Three-byte internal device address" ] _3_BYTE } impl IADRSZW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { IADRSZW :: NONE => 0 , IADRSZW :: _1_BYTE => 1 , IADRSZW :: _2_BYTE => 2 , IADRSZW :: _3_BYTE => 3 } } } # [ doc = r" Proxy" ] pub struct _IADRSZW < 'a > { w : & 'a mut W , } impl < 'a > _IADRSZW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : IADRSZW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "No internal device address" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( IADRSZW :: NONE ) } # [ doc = "One-byte internal device address" ] # [ inline ] pub fn _1_byte ( self ) -> & 'a mut W { self . variant ( IADRSZW :: _1_BYTE ) } # [ doc = "Two-byte internal device address" ] # [ inline ] pub fn _2_byte ( self ) -> & 'a mut W { self . variant ( IADRSZW :: _2_BYTE ) } # [ doc = "Three-byte internal device address" ] # [ inline ] pub fn _3_byte ( self ) -> & 'a mut W { self . variant ( IADRSZW :: _3_BYTE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _MREADW < 'a > { w : & 'a mut W , } impl < 'a > _MREADW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DADRW < 'a > { w : & 'a mut W , } impl < 'a > _DADRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 8:9 - Internal Device Address Size" ] # [ inline ] pub fn iadrsz ( & self ) -> IADRSZR { IADRSZR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Master Read Direction" ] # [ inline ] pub fn mread ( & self ) -> MREADR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MREADR { bits } } # [ doc = "Bits 16:22 - Device Address" ] # [ inline ] pub fn dadr ( & self ) -> DADRR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DADRR { 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 - Internal Device Address Size" ] # [ inline ] pub fn iadrsz ( & mut self ) -> _IADRSZW { _IADRSZW { w : self } } # [ doc = "Bit 12 - Master Read Direction" ] # [ inline ] pub fn mread ( & mut self ) -> _MREADW { _MREADW { w : self } } # [ doc = "Bits 16:22 - Device Address" ] # [ inline ] pub fn dadr ( & mut self ) -> _DADRW { _DADRW { w : self } } } } # [ doc = "Slave Mode Register" ] pub struct SMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Slave Mode Register" ] pub mod smr { # [ 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 :: SMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADRR { bits : u8 , } impl SADRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADRW < 'a > { w : & 'a mut W , } impl < 'a > _SADRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 16:22 - Slave Address" ] # [ inline ] pub fn sadr ( & self ) -> SADRR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SADRR { 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:22 - Slave Address" ] # [ inline ] pub fn sadr ( & mut self ) -> _SADRW { _SADRW { w : self } } } } # [ doc = "Internal Address Register" ] pub struct IADR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Internal Address Register" ] pub mod iadr { # [ 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 :: IADR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IADRR { bits : u32 , } impl IADRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _IADRW < 'a > { w : & 'a mut W , } impl < 'a > _IADRW < '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 0:23 - Internal Address" ] # [ inline ] pub fn iadr ( & self ) -> IADRR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; IADRR { 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:23 - Internal Address" ] # [ inline ] pub fn iadr ( & mut self ) -> _IADRW { _IADRW { w : self } } } } # [ doc = "Clock Waveform Generator Register" ] pub struct CWGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Clock Waveform Generator Register" ] pub mod cwgr { # [ 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 :: CWGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CLDIVR { bits : u8 , } impl CLDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CHDIVR { bits : u8 , } impl CHDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CKDIVR { bits : u8 , } impl CKDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CLDIVW < 'a > { w : & 'a mut W , } impl < 'a > _CLDIVW < '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 _CHDIVW < 'a > { w : & 'a mut W , } impl < 'a > _CHDIVW < '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 _CKDIVW < 'a > { w : & 'a mut W , } impl < 'a > _CKDIVW < '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 = 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:7 - Clock Low Divider" ] # [ inline ] pub fn cldiv ( & self ) -> CLDIVR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CLDIVR { bits } } # [ doc = "Bits 8:15 - Clock High Divider" ] # [ inline ] pub fn chdiv ( & self ) -> CHDIVR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CHDIVR { bits } } # [ doc = "Bits 16:18 - Clock Divider" ] # [ inline ] pub fn ckdiv ( & self ) -> CKDIVR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CKDIVR { 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 - Clock Low Divider" ] # [ inline ] pub fn cldiv ( & mut self ) -> _CLDIVW { _CLDIVW { w : self } } # [ doc = "Bits 8:15 - Clock High Divider" ] # [ inline ] pub fn chdiv ( & mut self ) -> _CHDIVW { _CHDIVW { w : self } } # [ doc = "Bits 16:18 - Clock Divider" ] # [ inline ] pub fn ckdiv ( & mut self ) -> _CKDIVW { _CKDIVW { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 TXCOMPR { bits : bool , } impl TXCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SVREADR { bits : bool , } impl SVREADR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SVACCR { bits : bool , } impl SVACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GACCR { bits : bool , } impl GACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ARBLSTR { bits : bool , } impl ARBLSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCLWSR { bits : bool , } impl SCLWSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOSACCR { bits : bool , } impl EOSACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmission Completed (automatically set / reset)" ] # [ inline ] pub fn txcomp ( & self ) -> TXCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXCOMPR { bits } } # [ doc = "Bit 1 - Receive Holding Register Ready (automatically set / reset)" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 2 - Transmit Holding Register Ready (automatically set / reset)" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3 - Slave Read (automatically set / reset)" ] # [ inline ] pub fn svread ( & self ) -> SVREADR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SVREADR { bits } } # [ doc = "Bit 4 - Slave Access (automatically set / reset)" ] # [ inline ] pub fn svacc ( & self ) -> SVACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SVACCR { bits } } # [ doc = "Bit 5 - General Call Access (clear on read)" ] # [ inline ] pub fn gacc ( & self ) -> GACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GACCR { bits } } # [ doc = "Bit 6 - Overrun Error (clear on read)" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 8 - Not Acknowledged (clear on read)" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 9 - Arbitration Lost (clear on read)" ] # [ inline ] pub fn arblst ( & self ) -> ARBLSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ARBLSTR { bits } } # [ doc = "Bit 10 - Clock Wait State (automatically set / reset)" ] # [ inline ] pub fn sclws ( & self ) -> SCLWSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCLWSR { bits } } # [ doc = "Bit 11 - End Of Slave Access (clear on read)" ] # [ inline ] pub fn eosacc ( & self ) -> EOSACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOSACCR { bits } } # [ doc = "Bit 12 - End of RX buffer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 13 - End of TX buffer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 14 - RX Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 15 - TX Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _TXCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVACCW < 'a > { w : & 'a mut W , } impl < 'a > _SVACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GACCW < 'a > { w : & 'a mut W , } impl < 'a > _GACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ARBLSTW < 'a > { w : & 'a mut W , } impl < 'a > _ARBLSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCL_WSW < 'a > { w : & 'a mut W , } impl < 'a > _SCL_WSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOSACCW < 'a > { w : & 'a mut W , } impl < 'a > _EOSACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Transmission Completed Interrupt Enable" ] # [ inline ] pub fn txcomp ( & mut self ) -> _TXCOMPW { _TXCOMPW { w : self } } # [ doc = "Bit 1 - Receive Holding Register Ready Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 2 - Transmit Holding Register Ready Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 4 - Slave Access Interrupt Enable" ] # [ inline ] pub fn svacc ( & mut self ) -> _SVACCW { _SVACCW { w : self } } # [ doc = "Bit 5 - General Call Access Interrupt Enable" ] # [ inline ] pub fn gacc ( & mut self ) -> _GACCW { _GACCW { w : self } } # [ doc = "Bit 6 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 8 - Not Acknowledge Interrupt Enable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 9 - Arbitration Lost Interrupt Enable" ] # [ inline ] pub fn arblst ( & mut self ) -> _ARBLSTW { _ARBLSTW { w : self } } # [ doc = "Bit 10 - Clock Wait State Interrupt Enable" ] # [ inline ] pub fn scl_ws ( & mut self ) -> _SCL_WSW { _SCL_WSW { w : self } } # [ doc = "Bit 11 - End Of Slave Access Interrupt Enable" ] # [ inline ] pub fn eosacc ( & mut self ) -> _EOSACCW { _EOSACCW { w : self } } # [ doc = "Bit 12 - End of Receive Buffer Interrupt Enable" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 13 - End of Transmit Buffer Interrupt Enable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 14 - Receive Buffer Full Interrupt Enable" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 15 - Transmit Buffer Empty Interrupt Enable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _TXCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVACCW < 'a > { w : & 'a mut W , } impl < 'a > _SVACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GACCW < 'a > { w : & 'a mut W , } impl < 'a > _GACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ARBLSTW < 'a > { w : & 'a mut W , } impl < 'a > _ARBLSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCL_WSW < 'a > { w : & 'a mut W , } impl < 'a > _SCL_WSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOSACCW < 'a > { w : & 'a mut W , } impl < 'a > _EOSACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Transmission Completed Interrupt Disable" ] # [ inline ] pub fn txcomp ( & mut self ) -> _TXCOMPW { _TXCOMPW { w : self } } # [ doc = "Bit 1 - Receive Holding Register Ready Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 2 - Transmit Holding Register Ready Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 4 - Slave Access Interrupt Disable" ] # [ inline ] pub fn svacc ( & mut self ) -> _SVACCW { _SVACCW { w : self } } # [ doc = "Bit 5 - General Call Access Interrupt Disable" ] # [ inline ] pub fn gacc ( & mut self ) -> _GACCW { _GACCW { w : self } } # [ doc = "Bit 6 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 8 - Not Acknowledge Interrupt Disable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 9 - Arbitration Lost Interrupt Disable" ] # [ inline ] pub fn arblst ( & mut self ) -> _ARBLSTW { _ARBLSTW { w : self } } # [ doc = "Bit 10 - Clock Wait State Interrupt Disable" ] # [ inline ] pub fn scl_ws ( & mut self ) -> _SCL_WSW { _SCL_WSW { w : self } } # [ doc = "Bit 11 - End Of Slave Access Interrupt Disable" ] # [ inline ] pub fn eosacc ( & mut self ) -> _EOSACCW { _EOSACCW { w : self } } # [ doc = "Bit 12 - End of Receive Buffer Interrupt Disable" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 13 - End of Transmit Buffer Interrupt Disable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 14 - Receive Buffer Full Interrupt Disable" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 15 - Transmit Buffer Empty Interrupt Disable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 TXCOMPR { bits : bool , } impl TXCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SVACCR { bits : bool , } impl SVACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GACCR { bits : bool , } impl GACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ARBLSTR { bits : bool , } impl ARBLSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCL_WSR { bits : bool , } impl SCL_WSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOSACCR { bits : bool , } impl EOSACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmission Completed Interrupt Mask" ] # [ inline ] pub fn txcomp ( & self ) -> TXCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXCOMPR { bits } } # [ doc = "Bit 1 - Receive Holding Register Ready Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 2 - Transmit Holding Register Ready Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 4 - Slave Access Interrupt Mask" ] # [ inline ] pub fn svacc ( & self ) -> SVACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SVACCR { bits } } # [ doc = "Bit 5 - General Call Access Interrupt Mask" ] # [ inline ] pub fn gacc ( & self ) -> GACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GACCR { bits } } # [ doc = "Bit 6 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 8 - Not Acknowledge Interrupt Mask" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 9 - Arbitration Lost Interrupt Mask" ] # [ inline ] pub fn arblst ( & self ) -> ARBLSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ARBLSTR { bits } } # [ doc = "Bit 10 - Clock Wait State Interrupt Mask" ] # [ inline ] pub fn scl_ws ( & self ) -> SCL_WSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCL_WSR { bits } } # [ doc = "Bit 11 - End Of Slave Access Interrupt Mask" ] # [ inline ] pub fn eosacc ( & self ) -> EOSACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOSACCR { bits } } # [ doc = "Bit 12 - End of Receive Buffer Interrupt Mask" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 13 - End of Transmit Buffer Interrupt Mask" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 14 - Receive Buffer Full Interrupt Mask" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 15 - Transmit Buffer Empty Interrupt Mask" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 - Master or Slave Receive Holding 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 Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _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 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 - Master or Slave Transmit Holding Data" ] # [ inline ] pub fn txdata ( & mut self ) -> _TXDATAW { _TXDATAW { w : self } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Two-wire Interface 1" ] pub struct TWI1 { _marker : PhantomData < * const ( ) > } unsafe impl Send for TWI1 { } impl TWI1 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const twi1 :: RegisterBlock { 0x4009_0000 as * const _ } } impl Deref for TWI1 { type Target = twi1 :: RegisterBlock ; fn deref ( & self ) -> & twi1 :: RegisterBlock { unsafe { & * TWI1 :: ptr ( ) } } } # [ doc = "Two-wire Interface 1" ] pub mod twi1 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Master Mode Register" ] pub mmr : MMR , # [ doc = "0x08 - Slave Mode Register" ] pub smr : SMR , # [ doc = "0x0c - Internal Address Register" ] pub iadr : IADR , # [ doc = "0x10 - Clock Waveform Generator Register" ] pub cwgr : CWGR , _reserved5 : [ u8 ; 12usize ] , # [ doc = "0x20 - Status Register" ] pub sr : SR , # [ doc = "0x24 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x28 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x2c - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x30 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x34 - Transmit Holding Register" ] pub thr : THR , _reserved11 : [ u8 ; 200usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; 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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _MSENW < 'a > { w : & 'a mut W , } impl < 'a > _MSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSDISW < 'a > { w : & 'a mut W , } impl < 'a > _MSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVENW < 'a > { w : & 'a mut W , } impl < 'a > _SVENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVDISW < 'a > { w : & 'a mut W , } impl < 'a > _SVDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _QUICKW < 'a > { w : & 'a mut W , } impl < 'a > _QUICKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 7 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bit 0 - Send a START Condition" ] # [ inline ] pub fn start ( & mut self ) -> _STARTW { _STARTW { w : self } } # [ doc = "Bit 1 - Send a STOP Condition" ] # [ inline ] pub fn stop ( & mut self ) -> _STOPW { _STOPW { w : self } } # [ doc = "Bit 2 - TWI Master Mode Enabled" ] # [ inline ] pub fn msen ( & mut self ) -> _MSENW { _MSENW { w : self } } # [ doc = "Bit 3 - TWI Master Mode Disabled" ] # [ inline ] pub fn msdis ( & mut self ) -> _MSDISW { _MSDISW { w : self } } # [ doc = "Bit 4 - TWI Slave Mode Enabled" ] # [ inline ] pub fn sven ( & mut self ) -> _SVENW { _SVENW { w : self } } # [ doc = "Bit 5 - TWI Slave Mode Disabled" ] # [ inline ] pub fn svdis ( & mut self ) -> _SVDISW { _SVDISW { w : self } } # [ doc = "Bit 6 - SMBUS Quick Command" ] # [ inline ] pub fn quick ( & mut self ) -> _QUICKW { _QUICKW { w : self } } # [ doc = "Bit 7 - Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } } } # [ doc = "Master Mode Register" ] pub struct MMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Master Mode Register" ] pub mod mmr { # [ 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 :: MMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `IADRSZ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum IADRSZR { # [ doc = "No internal device address" ] NONE , # [ doc = "One-byte internal device address" ] _1_BYTE , # [ doc = "Two-byte internal device address" ] _2_BYTE , # [ doc = "Three-byte internal device address" ] _3_BYTE } impl IADRSZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { IADRSZR :: NONE => 0 , IADRSZR :: _1_BYTE => 0x01 , IADRSZR :: _2_BYTE => 0x02 , IADRSZR :: _3_BYTE => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> IADRSZR { match value { 0 => IADRSZR :: NONE , 1 => IADRSZR :: _1_BYTE , 2 => IADRSZR :: _2_BYTE , 3 => IADRSZR :: _3_BYTE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == IADRSZR :: NONE } # [ doc = "Checks if the value of the field is `_1_BYTE`" ] # [ inline ] pub fn is_1_byte ( & self ) -> bool { * self == IADRSZR :: _1_BYTE } # [ doc = "Checks if the value of the field is `_2_BYTE`" ] # [ inline ] pub fn is_2_byte ( & self ) -> bool { * self == IADRSZR :: _2_BYTE } # [ doc = "Checks if the value of the field is `_3_BYTE`" ] # [ inline ] pub fn is_3_byte ( & self ) -> bool { * self == IADRSZR :: _3_BYTE } } # [ doc = r" Value of the field" ] pub struct MREADR { bits : bool , } impl MREADR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DADRR { bits : u8 , } impl DADRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Values that can be written to the field `IADRSZ`" ] pub enum IADRSZW { # [ doc = "No internal device address" ] NONE , # [ doc = "One-byte internal device address" ] _1_BYTE , # [ doc = "Two-byte internal device address" ] _2_BYTE , # [ doc = "Three-byte internal device address" ] _3_BYTE } impl IADRSZW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { IADRSZW :: NONE => 0 , IADRSZW :: _1_BYTE => 1 , IADRSZW :: _2_BYTE => 2 , IADRSZW :: _3_BYTE => 3 } } } # [ doc = r" Proxy" ] pub struct _IADRSZW < 'a > { w : & 'a mut W , } impl < 'a > _IADRSZW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : IADRSZW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "No internal device address" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( IADRSZW :: NONE ) } # [ doc = "One-byte internal device address" ] # [ inline ] pub fn _1_byte ( self ) -> & 'a mut W { self . variant ( IADRSZW :: _1_BYTE ) } # [ doc = "Two-byte internal device address" ] # [ inline ] pub fn _2_byte ( self ) -> & 'a mut W { self . variant ( IADRSZW :: _2_BYTE ) } # [ doc = "Three-byte internal device address" ] # [ inline ] pub fn _3_byte ( self ) -> & 'a mut W { self . variant ( IADRSZW :: _3_BYTE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _MREADW < 'a > { w : & 'a mut W , } impl < 'a > _MREADW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DADRW < 'a > { w : & 'a mut W , } impl < 'a > _DADRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 8:9 - Internal Device Address Size" ] # [ inline ] pub fn iadrsz ( & self ) -> IADRSZR { IADRSZR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Master Read Direction" ] # [ inline ] pub fn mread ( & self ) -> MREADR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MREADR { bits } } # [ doc = "Bits 16:22 - Device Address" ] # [ inline ] pub fn dadr ( & self ) -> DADRR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DADRR { 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 - Internal Device Address Size" ] # [ inline ] pub fn iadrsz ( & mut self ) -> _IADRSZW { _IADRSZW { w : self } } # [ doc = "Bit 12 - Master Read Direction" ] # [ inline ] pub fn mread ( & mut self ) -> _MREADW { _MREADW { w : self } } # [ doc = "Bits 16:22 - Device Address" ] # [ inline ] pub fn dadr ( & mut self ) -> _DADRW { _DADRW { w : self } } } } # [ doc = "Slave Mode Register" ] pub struct SMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Slave Mode Register" ] pub mod smr { # [ 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 :: SMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADRR { bits : u8 , } impl SADRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADRW < 'a > { w : & 'a mut W , } impl < 'a > _SADRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 16:22 - Slave Address" ] # [ inline ] pub fn sadr ( & self ) -> SADRR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SADRR { 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:22 - Slave Address" ] # [ inline ] pub fn sadr ( & mut self ) -> _SADRW { _SADRW { w : self } } } } # [ doc = "Internal Address Register" ] pub struct IADR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Internal Address Register" ] pub mod iadr { # [ 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 :: IADR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IADRR { bits : u32 , } impl IADRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _IADRW < 'a > { w : & 'a mut W , } impl < 'a > _IADRW < '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 0:23 - Internal Address" ] # [ inline ] pub fn iadr ( & self ) -> IADRR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; IADRR { 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:23 - Internal Address" ] # [ inline ] pub fn iadr ( & mut self ) -> _IADRW { _IADRW { w : self } } } } # [ doc = "Clock Waveform Generator Register" ] pub struct CWGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Clock Waveform Generator Register" ] pub mod cwgr { # [ 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 :: CWGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CLDIVR { bits : u8 , } impl CLDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CHDIVR { bits : u8 , } impl CHDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CKDIVR { bits : u8 , } impl CKDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CLDIVW < 'a > { w : & 'a mut W , } impl < 'a > _CLDIVW < '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 _CHDIVW < 'a > { w : & 'a mut W , } impl < 'a > _CHDIVW < '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 _CKDIVW < 'a > { w : & 'a mut W , } impl < 'a > _CKDIVW < '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 = 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:7 - Clock Low Divider" ] # [ inline ] pub fn cldiv ( & self ) -> CLDIVR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CLDIVR { bits } } # [ doc = "Bits 8:15 - Clock High Divider" ] # [ inline ] pub fn chdiv ( & self ) -> CHDIVR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CHDIVR { bits } } # [ doc = "Bits 16:18 - Clock Divider" ] # [ inline ] pub fn ckdiv ( & self ) -> CKDIVR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CKDIVR { 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 - Clock Low Divider" ] # [ inline ] pub fn cldiv ( & mut self ) -> _CLDIVW { _CLDIVW { w : self } } # [ doc = "Bits 8:15 - Clock High Divider" ] # [ inline ] pub fn chdiv ( & mut self ) -> _CHDIVW { _CHDIVW { w : self } } # [ doc = "Bits 16:18 - Clock Divider" ] # [ inline ] pub fn ckdiv ( & mut self ) -> _CKDIVW { _CKDIVW { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 TXCOMPR { bits : bool , } impl TXCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SVREADR { bits : bool , } impl SVREADR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SVACCR { bits : bool , } impl SVACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GACCR { bits : bool , } impl GACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ARBLSTR { bits : bool , } impl ARBLSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCLWSR { bits : bool , } impl SCLWSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOSACCR { bits : bool , } impl EOSACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmission Completed (automatically set / reset)" ] # [ inline ] pub fn txcomp ( & self ) -> TXCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXCOMPR { bits } } # [ doc = "Bit 1 - Receive Holding Register Ready (automatically set / reset)" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 2 - Transmit Holding Register Ready (automatically set / reset)" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3 - Slave Read (automatically set / reset)" ] # [ inline ] pub fn svread ( & self ) -> SVREADR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SVREADR { bits } } # [ doc = "Bit 4 - Slave Access (automatically set / reset)" ] # [ inline ] pub fn svacc ( & self ) -> SVACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SVACCR { bits } } # [ doc = "Bit 5 - General Call Access (clear on read)" ] # [ inline ] pub fn gacc ( & self ) -> GACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GACCR { bits } } # [ doc = "Bit 6 - Overrun Error (clear on read)" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 8 - Not Acknowledged (clear on read)" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 9 - Arbitration Lost (clear on read)" ] # [ inline ] pub fn arblst ( & self ) -> ARBLSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ARBLSTR { bits } } # [ doc = "Bit 10 - Clock Wait State (automatically set / reset)" ] # [ inline ] pub fn sclws ( & self ) -> SCLWSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCLWSR { bits } } # [ doc = "Bit 11 - End Of Slave Access (clear on read)" ] # [ inline ] pub fn eosacc ( & self ) -> EOSACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOSACCR { bits } } # [ doc = "Bit 12 - End of RX buffer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 13 - End of TX buffer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 14 - RX Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 15 - TX Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _TXCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVACCW < 'a > { w : & 'a mut W , } impl < 'a > _SVACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GACCW < 'a > { w : & 'a mut W , } impl < 'a > _GACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ARBLSTW < 'a > { w : & 'a mut W , } impl < 'a > _ARBLSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCL_WSW < 'a > { w : & 'a mut W , } impl < 'a > _SCL_WSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOSACCW < 'a > { w : & 'a mut W , } impl < 'a > _EOSACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Transmission Completed Interrupt Enable" ] # [ inline ] pub fn txcomp ( & mut self ) -> _TXCOMPW { _TXCOMPW { w : self } } # [ doc = "Bit 1 - Receive Holding Register Ready Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 2 - Transmit Holding Register Ready Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 4 - Slave Access Interrupt Enable" ] # [ inline ] pub fn svacc ( & mut self ) -> _SVACCW { _SVACCW { w : self } } # [ doc = "Bit 5 - General Call Access Interrupt Enable" ] # [ inline ] pub fn gacc ( & mut self ) -> _GACCW { _GACCW { w : self } } # [ doc = "Bit 6 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 8 - Not Acknowledge Interrupt Enable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 9 - Arbitration Lost Interrupt Enable" ] # [ inline ] pub fn arblst ( & mut self ) -> _ARBLSTW { _ARBLSTW { w : self } } # [ doc = "Bit 10 - Clock Wait State Interrupt Enable" ] # [ inline ] pub fn scl_ws ( & mut self ) -> _SCL_WSW { _SCL_WSW { w : self } } # [ doc = "Bit 11 - End Of Slave Access Interrupt Enable" ] # [ inline ] pub fn eosacc ( & mut self ) -> _EOSACCW { _EOSACCW { w : self } } # [ doc = "Bit 12 - End of Receive Buffer Interrupt Enable" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 13 - End of Transmit Buffer Interrupt Enable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 14 - Receive Buffer Full Interrupt Enable" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 15 - Transmit Buffer Empty Interrupt Enable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _TXCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SVACCW < 'a > { w : & 'a mut W , } impl < 'a > _SVACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GACCW < 'a > { w : & 'a mut W , } impl < 'a > _GACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ARBLSTW < 'a > { w : & 'a mut W , } impl < 'a > _ARBLSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCL_WSW < 'a > { w : & 'a mut W , } impl < 'a > _SCL_WSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOSACCW < 'a > { w : & 'a mut W , } impl < 'a > _EOSACCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Transmission Completed Interrupt Disable" ] # [ inline ] pub fn txcomp ( & mut self ) -> _TXCOMPW { _TXCOMPW { w : self } } # [ doc = "Bit 1 - Receive Holding Register Ready Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 2 - Transmit Holding Register Ready Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 4 - Slave Access Interrupt Disable" ] # [ inline ] pub fn svacc ( & mut self ) -> _SVACCW { _SVACCW { w : self } } # [ doc = "Bit 5 - General Call Access Interrupt Disable" ] # [ inline ] pub fn gacc ( & mut self ) -> _GACCW { _GACCW { w : self } } # [ doc = "Bit 6 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 8 - Not Acknowledge Interrupt Disable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 9 - Arbitration Lost Interrupt Disable" ] # [ inline ] pub fn arblst ( & mut self ) -> _ARBLSTW { _ARBLSTW { w : self } } # [ doc = "Bit 10 - Clock Wait State Interrupt Disable" ] # [ inline ] pub fn scl_ws ( & mut self ) -> _SCL_WSW { _SCL_WSW { w : self } } # [ doc = "Bit 11 - End Of Slave Access Interrupt Disable" ] # [ inline ] pub fn eosacc ( & mut self ) -> _EOSACCW { _EOSACCW { w : self } } # [ doc = "Bit 12 - End of Receive Buffer Interrupt Disable" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 13 - End of Transmit Buffer Interrupt Disable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 14 - Receive Buffer Full Interrupt Disable" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 15 - Transmit Buffer Empty Interrupt Disable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 TXCOMPR { bits : bool , } impl TXCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SVACCR { bits : bool , } impl SVACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GACCR { bits : bool , } impl GACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ARBLSTR { bits : bool , } impl ARBLSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCL_WSR { bits : bool , } impl SCL_WSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOSACCR { bits : bool , } impl EOSACCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmission Completed Interrupt Mask" ] # [ inline ] pub fn txcomp ( & self ) -> TXCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXCOMPR { bits } } # [ doc = "Bit 1 - Receive Holding Register Ready Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 2 - Transmit Holding Register Ready Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 4 - Slave Access Interrupt Mask" ] # [ inline ] pub fn svacc ( & self ) -> SVACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SVACCR { bits } } # [ doc = "Bit 5 - General Call Access Interrupt Mask" ] # [ inline ] pub fn gacc ( & self ) -> GACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GACCR { bits } } # [ doc = "Bit 6 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 8 - Not Acknowledge Interrupt Mask" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 9 - Arbitration Lost Interrupt Mask" ] # [ inline ] pub fn arblst ( & self ) -> ARBLSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ARBLSTR { bits } } # [ doc = "Bit 10 - Clock Wait State Interrupt Mask" ] # [ inline ] pub fn scl_ws ( & self ) -> SCL_WSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCL_WSR { bits } } # [ doc = "Bit 11 - End Of Slave Access Interrupt Mask" ] # [ inline ] pub fn eosacc ( & self ) -> EOSACCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOSACCR { bits } } # [ doc = "Bit 12 - End of Receive Buffer Interrupt Mask" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 13 - End of Transmit Buffer Interrupt Mask" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 14 - Receive Buffer Full Interrupt Mask" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 15 - Transmit Buffer Empty Interrupt Mask" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 - Master or Slave Receive Holding 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 Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _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 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 - Master or Slave Transmit Holding Data" ] # [ inline ] pub fn txdata ( & mut self ) -> _TXDATAW { _TXDATAW { w : self } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Pulse Width Modulation Controller" ] pub struct PWM { _marker : PhantomData < * const ( ) > } unsafe impl Send for PWM { } impl PWM { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const pwm :: RegisterBlock { 0x4009_4000 as * const _ } } impl Deref for PWM { type Target = pwm :: RegisterBlock ; fn deref ( & self ) -> & pwm :: RegisterBlock { unsafe { & * PWM :: ptr ( ) } } } # [ doc = "Pulse Width Modulation Controller" ] pub mod pwm { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - PWM Clock Register" ] pub clk : CLK , # [ doc = "0x04 - PWM Enable Register" ] pub ena : ENA , # [ doc = "0x08 - PWM Disable Register" ] pub dis : DIS , # [ doc = "0x0c - PWM Status Register" ] pub sr : SR , # [ doc = "0x10 - PWM Interrupt Enable Register 1" ] pub ier1 : IER1 , # [ doc = "0x14 - PWM Interrupt Disable Register 1" ] pub idr1 : IDR1 , # [ doc = "0x18 - PWM Interrupt Mask Register 1" ] pub imr1 : IMR1 , # [ doc = "0x1c - PWM Interrupt Status Register 1" ] pub isr1 : ISR1 , # [ doc = "0x20 - PWM Sync Channels Mode Register" ] pub scm : SCM , _reserved9 : [ u8 ; 4usize ] , # [ doc = "0x28 - PWM Sync Channels Update Control Register" ] pub scuc : SCUC , # [ doc = "0x2c - PWM Sync Channels Update Period Register" ] pub scup : SCUP , # [ doc = "0x30 - PWM Sync Channels Update Period Update Register" ] pub scupupd : SCUPUPD , # [ doc = "0x34 - PWM Interrupt Enable Register 2" ] pub ier2 : IER2 , # [ doc = "0x38 - PWM Interrupt Disable Register 2" ] pub idr2 : IDR2 , # [ doc = "0x3c - PWM Interrupt Mask Register 2" ] pub imr2 : IMR2 , # [ doc = "0x40 - PWM Interrupt Status Register 2" ] pub isr2 : ISR2 , # [ doc = "0x44 - PWM Output Override Value Register" ] pub oov : OOV , # [ doc = "0x48 - PWM Output Selection Register" ] pub os : OS , # [ doc = "0x4c - PWM Output Selection Set Register" ] pub oss : OSS , # [ doc = "0x50 - PWM Output Selection Clear Register" ] pub osc : OSC , # [ doc = "0x54 - PWM Output Selection Set Update Register" ] pub ossupd : OSSUPD , # [ doc = "0x58 - PWM Output Selection Clear Update Register" ] pub oscupd : OSCUPD , # [ doc = "0x5c - PWM Fault Mode Register" ] pub fmr : FMR , # [ doc = "0x60 - PWM Fault Status Register" ] pub fsr : FSR , # [ doc = "0x64 - PWM Fault Clear Register" ] pub fcr : FCR , # [ doc = "0x68 - PWM Fault Protection Value Register" ] pub fpv : FPV , # [ doc = "0x6c - PWM Fault Protection Enable Register 1" ] pub fpe1 : FPE1 , # [ doc = "0x70 - PWM Fault Protection Enable Register 2" ] pub fpe2 : FPE2 , _reserved28 : [ u8 ; 8usize ] , # [ doc = "0x7c - PWM Event Line 0 Mode Register" ] pub elmr : [ ELMR ; 2 ] , _reserved29 : [ u8 ; 44usize ] , # [ doc = "0xb0 - PWM Stepper Motor Mode Register" ] pub smmr : SMMR , _reserved30 : [ u8 ; 48usize ] , # [ doc = "0xe4 - PWM Write Protect Control Register" ] pub wpcr : WPCR , # [ doc = "0xe8 - PWM Write Protect Status Register" ] pub wpsr : WPSR , _reserved32 : [ u8 ; 28usize ] , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , _reserved34 : [ u8 ; 8usize ] , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , _reserved38 : [ u8 ; 8usize ] , # [ doc = "0x130 - PWM Comparison 0 Value Register" ] pub cmpv0 : CMPV0 , # [ doc = "0x134 - PWM Comparison 0 Value Update Register" ] pub cmpvupd0 : CMPVUPD0 , # [ doc = "0x138 - PWM Comparison 0 Mode Register" ] pub cmpm0 : CMPM0 , # [ doc = "0x13c - PWM Comparison 0 Mode Update Register" ] pub cmpmupd0 : CMPMUPD0 , # [ doc = "0x140 - PWM Comparison 1 Value Register" ] pub cmpv1 : CMPV1 , # [ doc = "0x144 - PWM Comparison 1 Value Update Register" ] pub cmpvupd1 : CMPVUPD1 , # [ doc = "0x148 - PWM Comparison 1 Mode Register" ] pub cmpm1 : CMPM1 , # [ doc = "0x14c - PWM Comparison 1 Mode Update Register" ] pub cmpmupd1 : CMPMUPD1 , # [ doc = "0x150 - PWM Comparison 2 Value Register" ] pub cmpv2 : CMPV2 , # [ doc = "0x154 - PWM Comparison 2 Value Update Register" ] pub cmpvupd2 : CMPVUPD2 , # [ doc = "0x158 - PWM Comparison 2 Mode Register" ] pub cmpm2 : CMPM2 , # [ doc = "0x15c - PWM Comparison 2 Mode Update Register" ] pub cmpmupd2 : CMPMUPD2 , # [ doc = "0x160 - PWM Comparison 3 Value Register" ] pub cmpv3 : CMPV3 , # [ doc = "0x164 - PWM Comparison 3 Value Update Register" ] pub cmpvupd3 : CMPVUPD3 , # [ doc = "0x168 - PWM Comparison 3 Mode Register" ] pub cmpm3 : CMPM3 , # [ doc = "0x16c - PWM Comparison 3 Mode Update Register" ] pub cmpmupd3 : CMPMUPD3 , # [ doc = "0x170 - PWM Comparison 4 Value Register" ] pub cmpv4 : CMPV4 , # [ doc = "0x174 - PWM Comparison 4 Value Update Register" ] pub cmpvupd4 : CMPVUPD4 , # [ doc = "0x178 - PWM Comparison 4 Mode Register" ] pub cmpm4 : CMPM4 , # [ doc = "0x17c - PWM Comparison 4 Mode Update Register" ] pub cmpmupd4 : CMPMUPD4 , # [ doc = "0x180 - PWM Comparison 5 Value Register" ] pub cmpv5 : CMPV5 , # [ doc = "0x184 - PWM Comparison 5 Value Update Register" ] pub cmpvupd5 : CMPVUPD5 , # [ doc = "0x188 - PWM Comparison 5 Mode Register" ] pub cmpm5 : CMPM5 , # [ doc = "0x18c - PWM Comparison 5 Mode Update Register" ] pub cmpmupd5 : CMPMUPD5 , # [ doc = "0x190 - PWM Comparison 6 Value Register" ] pub cmpv6 : CMPV6 , # [ doc = "0x194 - PWM Comparison 6 Value Update Register" ] pub cmpvupd6 : CMPVUPD6 , # [ doc = "0x198 - PWM Comparison 6 Mode Register" ] pub cmpm6 : CMPM6 , # [ doc = "0x19c - PWM Comparison 6 Mode Update Register" ] pub cmpmupd6 : CMPMUPD6 , # [ doc = "0x1a0 - PWM Comparison 7 Value Register" ] pub cmpv7 : CMPV7 , # [ doc = "0x1a4 - PWM Comparison 7 Value Update Register" ] pub cmpvupd7 : CMPVUPD7 , # [ doc = "0x1a8 - PWM Comparison 7 Mode Register" ] pub cmpm7 : CMPM7 , # [ doc = "0x1ac - PWM Comparison 7 Mode Update Register" ] pub cmpmupd7 : CMPMUPD7 , _reserved70 : [ u8 ; 80usize ] , # [ doc = "0x200 - PWM Channel Mode Register (ch_num = 0)" ] pub cmr0 : CMR0 , # [ doc = "0x204 - PWM Channel Duty Cycle Register (ch_num = 0)" ] pub cdty0 : CDTY0 , # [ doc = "0x208 - PWM Channel Duty Cycle Update Register (ch_num = 0)" ] pub cdtyupd0 : CDTYUPD0 , # [ doc = "0x20c - PWM Channel Period Register (ch_num = 0)" ] pub cprd0 : CPRD0 , # [ doc = "0x210 - PWM Channel Period Update Register (ch_num = 0)" ] pub cprdupd0 : CPRDUPD0 , # [ doc = "0x214 - PWM Channel Counter Register (ch_num = 0)" ] pub ccnt0 : CCNT0 , # [ doc = "0x218 - PWM Channel Dead Time Register (ch_num = 0)" ] pub dt0 : DT0 , # [ doc = "0x21c - PWM Channel Dead Time Update Register (ch_num = 0)" ] pub dtupd0 : DTUPD0 , # [ doc = "0x220 - PWM Channel Mode Register (ch_num = 1)" ] pub cmr1 : CMR1 , # [ doc = "0x224 - PWM Channel Duty Cycle Register (ch_num = 1)" ] pub cdty1 : CDTY1 , # [ doc = "0x228 - PWM Channel Duty Cycle Update Register (ch_num = 1)" ] pub cdtyupd1 : CDTYUPD1 , # [ doc = "0x22c - PWM Channel Period Register (ch_num = 1)" ] pub cprd1 : CPRD1 , # [ doc = "0x230 - PWM Channel Period Update Register (ch_num = 1)" ] pub cprdupd1 : CPRDUPD1 , # [ doc = "0x234 - PWM Channel Counter Register (ch_num = 1)" ] pub ccnt1 : CCNT1 , # [ doc = "0x238 - PWM Channel Dead Time Register (ch_num = 1)" ] pub dt1 : DT1 , # [ doc = "0x23c - PWM Channel Dead Time Update Register (ch_num = 1)" ] pub dtupd1 : DTUPD1 , # [ doc = "0x240 - PWM Channel Mode Register (ch_num = 2)" ] pub cmr2 : CMR2 , # [ doc = "0x244 - PWM Channel Duty Cycle Register (ch_num = 2)" ] pub cdty2 : CDTY2 , # [ doc = "0x248 - PWM Channel Duty Cycle Update Register (ch_num = 2)" ] pub cdtyupd2 : CDTYUPD2 , # [ doc = "0x24c - PWM Channel Period Register (ch_num = 2)" ] pub cprd2 : CPRD2 , # [ doc = "0x250 - PWM Channel Period Update Register (ch_num = 2)" ] pub cprdupd2 : CPRDUPD2 , # [ doc = "0x254 - PWM Channel Counter Register (ch_num = 2)" ] pub ccnt2 : CCNT2 , # [ doc = "0x258 - PWM Channel Dead Time Register (ch_num = 2)" ] pub dt2 : DT2 , # [ doc = "0x25c - PWM Channel Dead Time Update Register (ch_num = 2)" ] pub dtupd2 : DTUPD2 , # [ doc = "0x260 - PWM Channel Mode Register (ch_num = 3)" ] pub cmr3 : CMR3 , # [ doc = "0x264 - PWM Channel Duty Cycle Register (ch_num = 3)" ] pub cdty3 : CDTY3 , # [ doc = "0x268 - PWM Channel Duty Cycle Update Register (ch_num = 3)" ] pub cdtyupd3 : CDTYUPD3 , # [ doc = "0x26c - PWM Channel Period Register (ch_num = 3)" ] pub cprd3 : CPRD3 , # [ doc = "0x270 - PWM Channel Period Update Register (ch_num = 3)" ] pub cprdupd3 : CPRDUPD3 , # [ doc = "0x274 - PWM Channel Counter Register (ch_num = 3)" ] pub ccnt3 : CCNT3 , # [ doc = "0x278 - PWM Channel Dead Time Register (ch_num = 3)" ] pub dt3 : DT3 , # [ doc = "0x27c - PWM Channel Dead Time Update Register (ch_num = 3)" ] pub dtupd3 : DTUPD3 , # [ doc = "0x280 - PWM Channel Mode Register (ch_num = 4)" ] pub cmr4 : CMR4 , # [ doc = "0x284 - PWM Channel Duty Cycle Register (ch_num = 4)" ] pub cdty4 : CDTY4 , # [ doc = "0x288 - PWM Channel Duty Cycle Update Register (ch_num = 4)" ] pub cdtyupd4 : CDTYUPD4 , # [ doc = "0x28c - PWM Channel Period Register (ch_num = 4)" ] pub cprd4 : CPRD4 , # [ doc = "0x290 - PWM Channel Period Update Register (ch_num = 4)" ] pub cprdupd4 : CPRDUPD4 , # [ doc = "0x294 - PWM Channel Counter Register (ch_num = 4)" ] pub ccnt4 : CCNT4 , # [ doc = "0x298 - PWM Channel Dead Time Register (ch_num = 4)" ] pub dt4 : DT4 , # [ doc = "0x29c - PWM Channel Dead Time Update Register (ch_num = 4)" ] pub dtupd4 : DTUPD4 , # [ doc = "0x2a0 - PWM Channel Mode Register (ch_num = 5)" ] pub cmr5 : CMR5 , # [ doc = "0x2a4 - PWM Channel Duty Cycle Register (ch_num = 5)" ] pub cdty5 : CDTY5 , # [ doc = "0x2a8 - PWM Channel Duty Cycle Update Register (ch_num = 5)" ] pub cdtyupd5 : CDTYUPD5 , # [ doc = "0x2ac - PWM Channel Period Register (ch_num = 5)" ] pub cprd5 : CPRD5 , # [ doc = "0x2b0 - PWM Channel Period Update Register (ch_num = 5)" ] pub cprdupd5 : CPRDUPD5 , # [ doc = "0x2b4 - PWM Channel Counter Register (ch_num = 5)" ] pub ccnt5 : CCNT5 , # [ doc = "0x2b8 - PWM Channel Dead Time Register (ch_num = 5)" ] pub dt5 : DT5 , # [ doc = "0x2bc - PWM Channel Dead Time Update Register (ch_num = 5)" ] pub dtupd5 : DTUPD5 , # [ doc = "0x2c0 - PWM Channel Mode Register (ch_num = 6)" ] pub cmr6 : CMR6 , # [ doc = "0x2c4 - PWM Channel Duty Cycle Register (ch_num = 6)" ] pub cdty6 : CDTY6 , # [ doc = "0x2c8 - PWM Channel Duty Cycle Update Register (ch_num = 6)" ] pub cdtyupd6 : CDTYUPD6 , # [ doc = "0x2cc - PWM Channel Period Register (ch_num = 6)" ] pub cprd6 : CPRD6 , # [ doc = "0x2d0 - PWM Channel Period Update Register (ch_num = 6)" ] pub cprdupd6 : CPRDUPD6 , # [ doc = "0x2d4 - PWM Channel Counter Register (ch_num = 6)" ] pub ccnt6 : CCNT6 , # [ doc = "0x2d8 - PWM Channel Dead Time Register (ch_num = 6)" ] pub dt6 : DT6 , # [ doc = "0x2dc - PWM Channel Dead Time Update Register (ch_num = 6)" ] pub dtupd6 : DTUPD6 , # [ doc = "0x2e0 - PWM Channel Mode Register (ch_num = 7)" ] pub cmr7 : CMR7 , # [ doc = "0x2e4 - PWM Channel Duty Cycle Register (ch_num = 7)" ] pub cdty7 : CDTY7 , # [ doc = "0x2e8 - PWM Channel Duty Cycle Update Register (ch_num = 7)" ] pub cdtyupd7 : CDTYUPD7 , # [ doc = "0x2ec - PWM Channel Period Register (ch_num = 7)" ] pub cprd7 : CPRD7 , # [ doc = "0x2f0 - PWM Channel Period Update Register (ch_num = 7)" ] pub cprdupd7 : CPRDUPD7 , # [ doc = "0x2f4 - PWM Channel Counter Register (ch_num = 7)" ] pub ccnt7 : CCNT7 , # [ doc = "0x2f8 - PWM Channel Dead Time Register (ch_num = 7)" ] pub dt7 : DT7 , # [ doc = "0x2fc - PWM Channel Dead Time Update Register (ch_num = 7)" ] pub dtupd7 : DTUPD7 , } # [ doc = "PWM Clock Register" ] pub struct CLK { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Clock Register" ] pub mod clk { # [ 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 :: CLK { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DIVAR { bits : u8 , } impl DIVAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PREAR { bits : u8 , } impl PREAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DIVBR { bits : u8 , } impl DIVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PREBR { bits : u8 , } impl PREBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _DIVAW < 'a > { w : & 'a mut W , } impl < 'a > _DIVAW < '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 _PREAW < 'a > { w : & 'a mut W , } impl < 'a > _PREAW < '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 _DIVBW < 'a > { w : & 'a mut W , } impl < 'a > _DIVBW < '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 _PREBW < 'a > { w : & 'a mut W , } impl < 'a > _PREBW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:7 - CLKA, CLKB Divide Factor" ] # [ inline ] pub fn diva ( & self ) -> DIVAR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DIVAR { bits } } # [ doc = "Bits 8:11 - CLKA, CLKB Source Clock Selection" ] # [ inline ] pub fn prea ( & self ) -> PREAR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PREAR { bits } } # [ doc = "Bits 16:23 - CLKA, CLKB Divide Factor" ] # [ inline ] pub fn divb ( & self ) -> DIVBR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DIVBR { bits } } # [ doc = "Bits 24:27 - CLKA, CLKB Source Clock Selection" ] # [ inline ] pub fn preb ( & self ) -> PREBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PREBR { 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 - CLKA, CLKB Divide Factor" ] # [ inline ] pub fn diva ( & mut self ) -> _DIVAW { _DIVAW { w : self } } # [ doc = "Bits 8:11 - CLKA, CLKB Source Clock Selection" ] # [ inline ] pub fn prea ( & mut self ) -> _PREAW { _PREAW { w : self } } # [ doc = "Bits 16:23 - CLKA, CLKB Divide Factor" ] # [ inline ] pub fn divb ( & mut self ) -> _DIVBW { _DIVBW { w : self } } # [ doc = "Bits 24:27 - CLKA, CLKB Source Clock Selection" ] # [ inline ] pub fn preb ( & mut self ) -> _PREBW { _PREBW { w : self } } } } # [ doc = "PWM Enable Register" ] pub struct ENA { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Enable Register" ] pub mod ena { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ENA { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CHID0W < 'a > { w : & 'a mut W , } impl < 'a > _CHID0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID1W < 'a > { w : & 'a mut W , } impl < 'a > _CHID1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID2W < 'a > { w : & 'a mut W , } impl < 'a > _CHID2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID3W < 'a > { w : & 'a mut W , } impl < 'a > _CHID3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID4W < 'a > { w : & 'a mut W , } impl < 'a > _CHID4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID5W < 'a > { w : & 'a mut W , } impl < 'a > _CHID5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID6W < 'a > { w : & 'a mut W , } impl < 'a > _CHID6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID7W < 'a > { w : & 'a mut W , } impl < 'a > _CHID7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Channel ID" ] # [ inline ] pub fn chid0 ( & mut self ) -> _CHID0W { _CHID0W { w : self } } # [ doc = "Bit 1 - Channel ID" ] # [ inline ] pub fn chid1 ( & mut self ) -> _CHID1W { _CHID1W { w : self } } # [ doc = "Bit 2 - Channel ID" ] # [ inline ] pub fn chid2 ( & mut self ) -> _CHID2W { _CHID2W { w : self } } # [ doc = "Bit 3 - Channel ID" ] # [ inline ] pub fn chid3 ( & mut self ) -> _CHID3W { _CHID3W { w : self } } # [ doc = "Bit 4 - Channel ID" ] # [ inline ] pub fn chid4 ( & mut self ) -> _CHID4W { _CHID4W { w : self } } # [ doc = "Bit 5 - Channel ID" ] # [ inline ] pub fn chid5 ( & mut self ) -> _CHID5W { _CHID5W { w : self } } # [ doc = "Bit 6 - Channel ID" ] # [ inline ] pub fn chid6 ( & mut self ) -> _CHID6W { _CHID6W { w : self } } # [ doc = "Bit 7 - Channel ID" ] # [ inline ] pub fn chid7 ( & mut self ) -> _CHID7W { _CHID7W { w : self } } } } # [ doc = "PWM Disable Register" ] pub struct DIS { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Disable Register" ] pub mod dis { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DIS { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CHID0W < 'a > { w : & 'a mut W , } impl < 'a > _CHID0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID1W < 'a > { w : & 'a mut W , } impl < 'a > _CHID1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID2W < 'a > { w : & 'a mut W , } impl < 'a > _CHID2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID3W < 'a > { w : & 'a mut W , } impl < 'a > _CHID3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID4W < 'a > { w : & 'a mut W , } impl < 'a > _CHID4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID5W < 'a > { w : & 'a mut W , } impl < 'a > _CHID5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID6W < 'a > { w : & 'a mut W , } impl < 'a > _CHID6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID7W < 'a > { w : & 'a mut W , } impl < 'a > _CHID7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Channel ID" ] # [ inline ] pub fn chid0 ( & mut self ) -> _CHID0W { _CHID0W { w : self } } # [ doc = "Bit 1 - Channel ID" ] # [ inline ] pub fn chid1 ( & mut self ) -> _CHID1W { _CHID1W { w : self } } # [ doc = "Bit 2 - Channel ID" ] # [ inline ] pub fn chid2 ( & mut self ) -> _CHID2W { _CHID2W { w : self } } # [ doc = "Bit 3 - Channel ID" ] # [ inline ] pub fn chid3 ( & mut self ) -> _CHID3W { _CHID3W { w : self } } # [ doc = "Bit 4 - Channel ID" ] # [ inline ] pub fn chid4 ( & mut self ) -> _CHID4W { _CHID4W { w : self } } # [ doc = "Bit 5 - Channel ID" ] # [ inline ] pub fn chid5 ( & mut self ) -> _CHID5W { _CHID5W { w : self } } # [ doc = "Bit 6 - Channel ID" ] # [ inline ] pub fn chid6 ( & mut self ) -> _CHID6W { _CHID6W { w : self } } # [ doc = "Bit 7 - Channel ID" ] # [ inline ] pub fn chid7 ( & mut self ) -> _CHID7W { _CHID7W { w : self } } } } # [ doc = "PWM Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM 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 CHID0R { bits : bool , } impl CHID0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID1R { bits : bool , } impl CHID1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID2R { bits : bool , } impl CHID2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID3R { bits : bool , } impl CHID3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID4R { bits : bool , } impl CHID4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID5R { bits : bool , } impl CHID5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID6R { bits : bool , } impl CHID6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID7R { bits : bool , } impl CHID7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 ID" ] # [ inline ] pub fn chid0 ( & self ) -> CHID0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID0R { bits } } # [ doc = "Bit 1 - Channel ID" ] # [ inline ] pub fn chid1 ( & self ) -> CHID1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID1R { bits } } # [ doc = "Bit 2 - Channel ID" ] # [ inline ] pub fn chid2 ( & self ) -> CHID2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID2R { bits } } # [ doc = "Bit 3 - Channel ID" ] # [ inline ] pub fn chid3 ( & self ) -> CHID3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID3R { bits } } # [ doc = "Bit 4 - Channel ID" ] # [ inline ] pub fn chid4 ( & self ) -> CHID4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID4R { bits } } # [ doc = "Bit 5 - Channel ID" ] # [ inline ] pub fn chid5 ( & self ) -> CHID5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID5R { bits } } # [ doc = "Bit 6 - Channel ID" ] # [ inline ] pub fn chid6 ( & self ) -> CHID6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID6R { bits } } # [ doc = "Bit 7 - Channel ID" ] # [ inline ] pub fn chid7 ( & self ) -> CHID7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID7R { bits } } } } # [ doc = "PWM Interrupt Enable Register 1" ] pub struct IER1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Enable Register 1" ] pub mod ier1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CHID0W < 'a > { w : & 'a mut W , } impl < 'a > _CHID0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID1W < 'a > { w : & 'a mut W , } impl < 'a > _CHID1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID2W < 'a > { w : & 'a mut W , } impl < 'a > _CHID2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID3W < 'a > { w : & 'a mut W , } impl < 'a > _CHID3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID4W < 'a > { w : & 'a mut W , } impl < 'a > _CHID4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID5W < 'a > { w : & 'a mut W , } impl < 'a > _CHID5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID6W < 'a > { w : & 'a mut W , } impl < 'a > _CHID6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID7W < 'a > { w : & 'a mut W , } impl < 'a > _CHID7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID0W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID1W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID2W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID3W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID4W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID5W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID6W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID7W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Event on Channel 0 Interrupt Enable" ] # [ inline ] pub fn chid0 ( & mut self ) -> _CHID0W { _CHID0W { w : self } } # [ doc = "Bit 1 - Counter Event on Channel 1 Interrupt Enable" ] # [ inline ] pub fn chid1 ( & mut self ) -> _CHID1W { _CHID1W { w : self } } # [ doc = "Bit 2 - Counter Event on Channel 2 Interrupt Enable" ] # [ inline ] pub fn chid2 ( & mut self ) -> _CHID2W { _CHID2W { w : self } } # [ doc = "Bit 3 - Counter Event on Channel 3 Interrupt Enable" ] # [ inline ] pub fn chid3 ( & mut self ) -> _CHID3W { _CHID3W { w : self } } # [ doc = "Bit 4 - Counter Event on Channel 4 Interrupt Enable" ] # [ inline ] pub fn chid4 ( & mut self ) -> _CHID4W { _CHID4W { w : self } } # [ doc = "Bit 5 - Counter Event on Channel 5 Interrupt Enable" ] # [ inline ] pub fn chid5 ( & mut self ) -> _CHID5W { _CHID5W { w : self } } # [ doc = "Bit 6 - Counter Event on Channel 6 Interrupt Enable" ] # [ inline ] pub fn chid6 ( & mut self ) -> _CHID6W { _CHID6W { w : self } } # [ doc = "Bit 7 - Counter Event on Channel 7 Interrupt Enable" ] # [ inline ] pub fn chid7 ( & mut self ) -> _CHID7W { _CHID7W { w : self } } # [ doc = "Bit 16 - Fault Protection Trigger on Channel 0 Interrupt Enable" ] # [ inline ] pub fn fchid0 ( & mut self ) -> _FCHID0W { _FCHID0W { w : self } } # [ doc = "Bit 17 - Fault Protection Trigger on Channel 1 Interrupt Enable" ] # [ inline ] pub fn fchid1 ( & mut self ) -> _FCHID1W { _FCHID1W { w : self } } # [ doc = "Bit 18 - Fault Protection Trigger on Channel 2 Interrupt Enable" ] # [ inline ] pub fn fchid2 ( & mut self ) -> _FCHID2W { _FCHID2W { w : self } } # [ doc = "Bit 19 - Fault Protection Trigger on Channel 3 Interrupt Enable" ] # [ inline ] pub fn fchid3 ( & mut self ) -> _FCHID3W { _FCHID3W { w : self } } # [ doc = "Bit 20 - Fault Protection Trigger on Channel 4 Interrupt Enable" ] # [ inline ] pub fn fchid4 ( & mut self ) -> _FCHID4W { _FCHID4W { w : self } } # [ doc = "Bit 21 - Fault Protection Trigger on Channel 5 Interrupt Enable" ] # [ inline ] pub fn fchid5 ( & mut self ) -> _FCHID5W { _FCHID5W { w : self } } # [ doc = "Bit 22 - Fault Protection Trigger on Channel 6 Interrupt Enable" ] # [ inline ] pub fn fchid6 ( & mut self ) -> _FCHID6W { _FCHID6W { w : self } } # [ doc = "Bit 23 - Fault Protection Trigger on Channel 7 Interrupt Enable" ] # [ inline ] pub fn fchid7 ( & mut self ) -> _FCHID7W { _FCHID7W { w : self } } } } # [ doc = "PWM Interrupt Disable Register 1" ] pub struct IDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Disable Register 1" ] pub mod idr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CHID0W < 'a > { w : & 'a mut W , } impl < 'a > _CHID0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID1W < 'a > { w : & 'a mut W , } impl < 'a > _CHID1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID2W < 'a > { w : & 'a mut W , } impl < 'a > _CHID2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID3W < 'a > { w : & 'a mut W , } impl < 'a > _CHID3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID4W < 'a > { w : & 'a mut W , } impl < 'a > _CHID4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID5W < 'a > { w : & 'a mut W , } impl < 'a > _CHID5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID6W < 'a > { w : & 'a mut W , } impl < 'a > _CHID6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHID7W < 'a > { w : & 'a mut W , } impl < 'a > _CHID7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID0W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID1W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID2W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID3W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID4W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID5W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID6W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCHID7W < 'a > { w : & 'a mut W , } impl < 'a > _FCHID7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Counter Event on Channel 0 Interrupt Disable" ] # [ inline ] pub fn chid0 ( & mut self ) -> _CHID0W { _CHID0W { w : self } } # [ doc = "Bit 1 - Counter Event on Channel 1 Interrupt Disable" ] # [ inline ] pub fn chid1 ( & mut self ) -> _CHID1W { _CHID1W { w : self } } # [ doc = "Bit 2 - Counter Event on Channel 2 Interrupt Disable" ] # [ inline ] pub fn chid2 ( & mut self ) -> _CHID2W { _CHID2W { w : self } } # [ doc = "Bit 3 - Counter Event on Channel 3 Interrupt Disable" ] # [ inline ] pub fn chid3 ( & mut self ) -> _CHID3W { _CHID3W { w : self } } # [ doc = "Bit 4 - Counter Event on Channel 4 Interrupt Disable" ] # [ inline ] pub fn chid4 ( & mut self ) -> _CHID4W { _CHID4W { w : self } } # [ doc = "Bit 5 - Counter Event on Channel 5 Interrupt Disable" ] # [ inline ] pub fn chid5 ( & mut self ) -> _CHID5W { _CHID5W { w : self } } # [ doc = "Bit 6 - Counter Event on Channel 6 Interrupt Disable" ] # [ inline ] pub fn chid6 ( & mut self ) -> _CHID6W { _CHID6W { w : self } } # [ doc = "Bit 7 - Counter Event on Channel 7 Interrupt Disable" ] # [ inline ] pub fn chid7 ( & mut self ) -> _CHID7W { _CHID7W { w : self } } # [ doc = "Bit 16 - Fault Protection Trigger on Channel 0 Interrupt Disable" ] # [ inline ] pub fn fchid0 ( & mut self ) -> _FCHID0W { _FCHID0W { w : self } } # [ doc = "Bit 17 - Fault Protection Trigger on Channel 1 Interrupt Disable" ] # [ inline ] pub fn fchid1 ( & mut self ) -> _FCHID1W { _FCHID1W { w : self } } # [ doc = "Bit 18 - Fault Protection Trigger on Channel 2 Interrupt Disable" ] # [ inline ] pub fn fchid2 ( & mut self ) -> _FCHID2W { _FCHID2W { w : self } } # [ doc = "Bit 19 - Fault Protection Trigger on Channel 3 Interrupt Disable" ] # [ inline ] pub fn fchid3 ( & mut self ) -> _FCHID3W { _FCHID3W { w : self } } # [ doc = "Bit 20 - Fault Protection Trigger on Channel 4 Interrupt Disable" ] # [ inline ] pub fn fchid4 ( & mut self ) -> _FCHID4W { _FCHID4W { w : self } } # [ doc = "Bit 21 - Fault Protection Trigger on Channel 5 Interrupt Disable" ] # [ inline ] pub fn fchid5 ( & mut self ) -> _FCHID5W { _FCHID5W { w : self } } # [ doc = "Bit 22 - Fault Protection Trigger on Channel 6 Interrupt Disable" ] # [ inline ] pub fn fchid6 ( & mut self ) -> _FCHID6W { _FCHID6W { w : self } } # [ doc = "Bit 23 - Fault Protection Trigger on Channel 7 Interrupt Disable" ] # [ inline ] pub fn fchid7 ( & mut self ) -> _FCHID7W { _FCHID7W { w : self } } } } # [ doc = "PWM Interrupt Mask Register 1" ] pub struct IMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Mask Register 1" ] pub mod imr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR1 { # [ 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 CHID0R { bits : bool , } impl CHID0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID1R { bits : bool , } impl CHID1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID2R { bits : bool , } impl CHID2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID3R { bits : bool , } impl CHID3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID4R { bits : bool , } impl CHID4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID5R { bits : bool , } impl CHID5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID6R { bits : bool , } impl CHID6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID7R { bits : bool , } impl CHID7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID0R { bits : bool , } impl FCHID0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID1R { bits : bool , } impl FCHID1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID2R { bits : bool , } impl FCHID2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID3R { bits : bool , } impl FCHID3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID4R { bits : bool , } impl FCHID4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID5R { bits : bool , } impl FCHID5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID6R { bits : bool , } impl FCHID6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID7R { bits : bool , } impl FCHID7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Event on Channel 0 Interrupt Mask" ] # [ inline ] pub fn chid0 ( & self ) -> CHID0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID0R { bits } } # [ doc = "Bit 1 - Counter Event on Channel 1 Interrupt Mask" ] # [ inline ] pub fn chid1 ( & self ) -> CHID1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID1R { bits } } # [ doc = "Bit 2 - Counter Event on Channel 2 Interrupt Mask" ] # [ inline ] pub fn chid2 ( & self ) -> CHID2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID2R { bits } } # [ doc = "Bit 3 - Counter Event on Channel 3 Interrupt Mask" ] # [ inline ] pub fn chid3 ( & self ) -> CHID3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID3R { bits } } # [ doc = "Bit 4 - Counter Event on Channel 4 Interrupt Mask" ] # [ inline ] pub fn chid4 ( & self ) -> CHID4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID4R { bits } } # [ doc = "Bit 5 - Counter Event on Channel 5 Interrupt Mask" ] # [ inline ] pub fn chid5 ( & self ) -> CHID5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID5R { bits } } # [ doc = "Bit 6 - Counter Event on Channel 6 Interrupt Mask" ] # [ inline ] pub fn chid6 ( & self ) -> CHID6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID6R { bits } } # [ doc = "Bit 7 - Counter Event on Channel 7 Interrupt Mask" ] # [ inline ] pub fn chid7 ( & self ) -> CHID7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID7R { bits } } # [ doc = "Bit 16 - Fault Protection Trigger on Channel 0 Interrupt Mask" ] # [ inline ] pub fn fchid0 ( & self ) -> FCHID0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID0R { bits } } # [ doc = "Bit 17 - Fault Protection Trigger on Channel 1 Interrupt Mask" ] # [ inline ] pub fn fchid1 ( & self ) -> FCHID1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID1R { bits } } # [ doc = "Bit 18 - Fault Protection Trigger on Channel 2 Interrupt Mask" ] # [ inline ] pub fn fchid2 ( & self ) -> FCHID2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID2R { bits } } # [ doc = "Bit 19 - Fault Protection Trigger on Channel 3 Interrupt Mask" ] # [ inline ] pub fn fchid3 ( & self ) -> FCHID3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID3R { bits } } # [ doc = "Bit 20 - Fault Protection Trigger on Channel 4 Interrupt Mask" ] # [ inline ] pub fn fchid4 ( & self ) -> FCHID4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID4R { bits } } # [ doc = "Bit 21 - Fault Protection Trigger on Channel 5 Interrupt Mask" ] # [ inline ] pub fn fchid5 ( & self ) -> FCHID5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID5R { bits } } # [ doc = "Bit 22 - Fault Protection Trigger on Channel 6 Interrupt Mask" ] # [ inline ] pub fn fchid6 ( & self ) -> FCHID6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID6R { bits } } # [ doc = "Bit 23 - Fault Protection Trigger on Channel 7 Interrupt Mask" ] # [ inline ] pub fn fchid7 ( & self ) -> FCHID7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID7R { bits } } } } # [ doc = "PWM Interrupt Status Register 1" ] pub struct ISR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Status Register 1" ] pub mod isr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ISR1 { # [ 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 CHID0R { bits : bool , } impl CHID0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID1R { bits : bool , } impl CHID1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID2R { bits : bool , } impl CHID2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID3R { bits : bool , } impl CHID3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID4R { bits : bool , } impl CHID4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID5R { bits : bool , } impl CHID5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID6R { bits : bool , } impl CHID6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHID7R { bits : bool , } impl CHID7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID0R { bits : bool , } impl FCHID0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID1R { bits : bool , } impl FCHID1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID2R { bits : bool , } impl FCHID2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID3R { bits : bool , } impl FCHID3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID4R { bits : bool , } impl FCHID4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID5R { bits : bool , } impl FCHID5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID6R { bits : bool , } impl FCHID6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCHID7R { bits : bool , } impl FCHID7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Counter Event on Channel 0" ] # [ inline ] pub fn chid0 ( & self ) -> CHID0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID0R { bits } } # [ doc = "Bit 1 - Counter Event on Channel 1" ] # [ inline ] pub fn chid1 ( & self ) -> CHID1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID1R { bits } } # [ doc = "Bit 2 - Counter Event on Channel 2" ] # [ inline ] pub fn chid2 ( & self ) -> CHID2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID2R { bits } } # [ doc = "Bit 3 - Counter Event on Channel 3" ] # [ inline ] pub fn chid3 ( & self ) -> CHID3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID3R { bits } } # [ doc = "Bit 4 - Counter Event on Channel 4" ] # [ inline ] pub fn chid4 ( & self ) -> CHID4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID4R { bits } } # [ doc = "Bit 5 - Counter Event on Channel 5" ] # [ inline ] pub fn chid5 ( & self ) -> CHID5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID5R { bits } } # [ doc = "Bit 6 - Counter Event on Channel 6" ] # [ inline ] pub fn chid6 ( & self ) -> CHID6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID6R { bits } } # [ doc = "Bit 7 - Counter Event on Channel 7" ] # [ inline ] pub fn chid7 ( & self ) -> CHID7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHID7R { bits } } # [ doc = "Bit 16 - Fault Protection Trigger on Channel 0" ] # [ inline ] pub fn fchid0 ( & self ) -> FCHID0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID0R { bits } } # [ doc = "Bit 17 - Fault Protection Trigger on Channel 1" ] # [ inline ] pub fn fchid1 ( & self ) -> FCHID1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID1R { bits } } # [ doc = "Bit 18 - Fault Protection Trigger on Channel 2" ] # [ inline ] pub fn fchid2 ( & self ) -> FCHID2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID2R { bits } } # [ doc = "Bit 19 - Fault Protection Trigger on Channel 3" ] # [ inline ] pub fn fchid3 ( & self ) -> FCHID3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID3R { bits } } # [ doc = "Bit 20 - Fault Protection Trigger on Channel 4" ] # [ inline ] pub fn fchid4 ( & self ) -> FCHID4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID4R { bits } } # [ doc = "Bit 21 - Fault Protection Trigger on Channel 5" ] # [ inline ] pub fn fchid5 ( & self ) -> FCHID5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID5R { bits } } # [ doc = "Bit 22 - Fault Protection Trigger on Channel 6" ] # [ inline ] pub fn fchid6 ( & self ) -> FCHID6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID6R { bits } } # [ doc = "Bit 23 - Fault Protection Trigger on Channel 7" ] # [ inline ] pub fn fchid7 ( & self ) -> FCHID7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCHID7R { bits } } } } # [ doc = "PWM Sync Channels Mode Register" ] pub struct SCM { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Sync Channels Mode Register" ] pub mod scm { # [ 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 :: SCM { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SYNC0R { bits : bool , } impl SYNC0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SYNC1R { bits : bool , } impl SYNC1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SYNC2R { bits : bool , } impl SYNC2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SYNC3R { bits : bool , } impl SYNC3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SYNC4R { bits : bool , } impl SYNC4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SYNC5R { bits : bool , } impl SYNC5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SYNC6R { bits : bool , } impl SYNC6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SYNC7R { bits : bool , } impl SYNC7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `UPDM`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum UPDMR { # [ doc = "Manual write of double buffer registers and manual update of synchronous channels" ] MODE0 , # [ doc = "Manual write of double buffer registers and automatic update of synchronous channels" ] MODE1 , # [ doc = "Automatic write of duty-cycle update registers by the PDC and automatic update of synchronous channels" ] MODE2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl UPDMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { UPDMR :: MODE0 => 0 , UPDMR :: MODE1 => 0x01 , UPDMR :: MODE2 => 0x02 , UPDMR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> UPDMR { match value { 0 => UPDMR :: MODE0 , 1 => UPDMR :: MODE1 , 2 => UPDMR :: MODE2 , i => UPDMR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MODE0`" ] # [ inline ] pub fn is_mode0 ( & self ) -> bool { * self == UPDMR :: MODE0 } # [ doc = "Checks if the value of the field is `MODE1`" ] # [ inline ] pub fn is_mode1 ( & self ) -> bool { * self == UPDMR :: MODE1 } # [ doc = "Checks if the value of the field is `MODE2`" ] # [ inline ] pub fn is_mode2 ( & self ) -> bool { * self == UPDMR :: MODE2 } } # [ doc = r" Value of the field" ] pub struct PTRMR { bits : bool , } impl PTRMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PTRCSR { bits : u8 , } impl PTRCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _SYNC0W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SYNC1W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SYNC2W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SYNC3W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SYNC4W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SYNC5W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SYNC6W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SYNC7W < 'a > { w : & 'a mut W , } impl < 'a > _SYNC7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `UPDM`" ] pub enum UPDMW { # [ doc = "Manual write of double buffer registers and manual update of synchronous channels" ] MODE0 , # [ doc = "Manual write of double buffer registers and automatic update of synchronous channels" ] MODE1 , # [ doc = "Automatic write of duty-cycle update registers by the PDC and automatic update of synchronous channels" ] MODE2 } impl UPDMW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { UPDMW :: MODE0 => 0 , UPDMW :: MODE1 => 1 , UPDMW :: MODE2 => 2 } } } # [ doc = r" Proxy" ] pub struct _UPDMW < 'a > { w : & 'a mut W , } impl < 'a > _UPDMW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : UPDMW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Manual write of double buffer registers and manual update of synchronous channels" ] # [ inline ] pub fn mode0 ( self ) -> & 'a mut W { self . variant ( UPDMW :: MODE0 ) } # [ doc = "Manual write of double buffer registers and automatic update of synchronous channels" ] # [ inline ] pub fn mode1 ( self ) -> & 'a mut W { self . variant ( UPDMW :: MODE1 ) } # [ doc = "Automatic write of duty-cycle update registers by the PDC and automatic update of synchronous channels" ] # [ inline ] pub fn mode2 ( self ) -> & 'a mut W { self . variant ( UPDMW :: MODE2 ) } # [ 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 _PTRMW < 'a > { w : & 'a mut W , } impl < 'a > _PTRMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PTRCSW < 'a > { w : & 'a mut W , } impl < 'a > _PTRCSW < '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 = 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 - Synchronous Channel 0" ] # [ inline ] pub fn sync0 ( & self ) -> SYNC0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC0R { bits } } # [ doc = "Bit 1 - Synchronous Channel 1" ] # [ inline ] pub fn sync1 ( & self ) -> SYNC1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC1R { bits } } # [ doc = "Bit 2 - Synchronous Channel 2" ] # [ inline ] pub fn sync2 ( & self ) -> SYNC2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC2R { bits } } # [ doc = "Bit 3 - Synchronous Channel 3" ] # [ inline ] pub fn sync3 ( & self ) -> SYNC3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC3R { bits } } # [ doc = "Bit 4 - Synchronous Channel 4" ] # [ inline ] pub fn sync4 ( & self ) -> SYNC4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC4R { bits } } # [ doc = "Bit 5 - Synchronous Channel 5" ] # [ inline ] pub fn sync5 ( & self ) -> SYNC5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC5R { bits } } # [ doc = "Bit 6 - Synchronous Channel 6" ] # [ inline ] pub fn sync6 ( & self ) -> SYNC6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC6R { bits } } # [ doc = "Bit 7 - Synchronous Channel 7" ] # [ inline ] pub fn sync7 ( & self ) -> SYNC7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNC7R { bits } } # [ doc = "Bits 16:17 - Synchronous Channels Update Mode" ] # [ inline ] pub fn updm ( & self ) -> UPDMR { UPDMR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 20 - PDC Transfer Request Mode" ] # [ inline ] pub fn ptrm ( & self ) -> PTRMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PTRMR { bits } } # [ doc = "Bits 21:23 - PDC Transfer Request Comparison Selection" ] # [ inline ] pub fn ptrcs ( & self ) -> PTRCSR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PTRCSR { 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 - Synchronous Channel 0" ] # [ inline ] pub fn sync0 ( & mut self ) -> _SYNC0W { _SYNC0W { w : self } } # [ doc = "Bit 1 - Synchronous Channel 1" ] # [ inline ] pub fn sync1 ( & mut self ) -> _SYNC1W { _SYNC1W { w : self } } # [ doc = "Bit 2 - Synchronous Channel 2" ] # [ inline ] pub fn sync2 ( & mut self ) -> _SYNC2W { _SYNC2W { w : self } } # [ doc = "Bit 3 - Synchronous Channel 3" ] # [ inline ] pub fn sync3 ( & mut self ) -> _SYNC3W { _SYNC3W { w : self } } # [ doc = "Bit 4 - Synchronous Channel 4" ] # [ inline ] pub fn sync4 ( & mut self ) -> _SYNC4W { _SYNC4W { w : self } } # [ doc = "Bit 5 - Synchronous Channel 5" ] # [ inline ] pub fn sync5 ( & mut self ) -> _SYNC5W { _SYNC5W { w : self } } # [ doc = "Bit 6 - Synchronous Channel 6" ] # [ inline ] pub fn sync6 ( & mut self ) -> _SYNC6W { _SYNC6W { w : self } } # [ doc = "Bit 7 - Synchronous Channel 7" ] # [ inline ] pub fn sync7 ( & mut self ) -> _SYNC7W { _SYNC7W { w : self } } # [ doc = "Bits 16:17 - Synchronous Channels Update Mode" ] # [ inline ] pub fn updm ( & mut self ) -> _UPDMW { _UPDMW { w : self } } # [ doc = "Bit 20 - PDC Transfer Request Mode" ] # [ inline ] pub fn ptrm ( & mut self ) -> _PTRMW { _PTRMW { w : self } } # [ doc = "Bits 21:23 - PDC Transfer Request Comparison Selection" ] # [ inline ] pub fn ptrcs ( & mut self ) -> _PTRCSW { _PTRCSW { w : self } } } } # [ doc = "PWM Sync Channels Update Control Register" ] pub struct SCUC { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Sync Channels Update Control Register" ] pub mod scuc { # [ 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 :: SCUC { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 UPDULOCKR { bits : bool , } impl UPDULOCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _UPDULOCKW < 'a > { w : & 'a mut W , } impl < 'a > _UPDULOCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Synchronous Channels Update Unlock" ] # [ inline ] pub fn updulock ( & self ) -> UPDULOCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UPDULOCKR { 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 - Synchronous Channels Update Unlock" ] # [ inline ] pub fn updulock ( & mut self ) -> _UPDULOCKW { _UPDULOCKW { w : self } } } } # [ doc = "PWM Sync Channels Update Period Register" ] pub struct SCUP { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Sync Channels Update Period Register" ] pub mod scup { # [ 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 :: SCUP { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 UPRR { bits : u8 , } impl UPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct UPRCNTR { bits : u8 , } impl UPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _UPRW < 'a > { w : & 'a mut W , } impl < 'a > _UPRW < '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 } } # [ doc = r" Proxy" ] pub struct _UPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _UPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Update Period" ] # [ inline ] pub fn upr ( & self ) -> UPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; UPRR { bits } } # [ doc = "Bits 4:7 - Update Period Counter" ] # [ inline ] pub fn uprcnt ( & self ) -> UPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; UPRCNTR { 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 - Update Period" ] # [ inline ] pub fn upr ( & mut self ) -> _UPRW { _UPRW { w : self } } # [ doc = "Bits 4:7 - Update Period Counter" ] # [ inline ] pub fn uprcnt ( & mut self ) -> _UPRCNTW { _UPRCNTW { w : self } } } } # [ doc = "PWM Sync Channels Update Period Update Register" ] pub struct SCUPUPD { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Sync Channels Update Period Update Register" ] pub mod scupupd { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SCUPUPD { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _UPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _UPRUPDW < '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 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 - Update Period Update" ] # [ inline ] pub fn uprupd ( & mut self ) -> _UPRUPDW { _UPRUPDW { w : self } } } } # [ doc = "PWM Interrupt Enable Register 2" ] pub struct IER2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Enable Register 2" ] pub mod ier2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _WRDYW < 'a > { w : & 'a mut W , } impl < 'a > _WRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM0W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM1W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM2W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM3W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM4W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM5W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM6W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM7W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU0W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU1W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU2W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU3W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU4W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU5W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU6W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU7W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Write Ready for Synchronous Channels Update Interrupt Enable" ] # [ inline ] pub fn wrdy ( & mut self ) -> _WRDYW { _WRDYW { w : self } } # [ doc = "Bit 1 - PDC End of TX Buffer Interrupt Enable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 2 - PDC TX Buffer Empty Interrupt Enable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 3 - Synchronous Channels Update Underrun Error Interrupt Enable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 8 - Comparison 0 Match Interrupt Enable" ] # [ inline ] pub fn cmpm0 ( & mut self ) -> _CMPM0W { _CMPM0W { w : self } } # [ doc = "Bit 9 - Comparison 1 Match Interrupt Enable" ] # [ inline ] pub fn cmpm1 ( & mut self ) -> _CMPM1W { _CMPM1W { w : self } } # [ doc = "Bit 10 - Comparison 2 Match Interrupt Enable" ] # [ inline ] pub fn cmpm2 ( & mut self ) -> _CMPM2W { _CMPM2W { w : self } } # [ doc = "Bit 11 - Comparison 3 Match Interrupt Enable" ] # [ inline ] pub fn cmpm3 ( & mut self ) -> _CMPM3W { _CMPM3W { w : self } } # [ doc = "Bit 12 - Comparison 4 Match Interrupt Enable" ] # [ inline ] pub fn cmpm4 ( & mut self ) -> _CMPM4W { _CMPM4W { w : self } } # [ doc = "Bit 13 - Comparison 5 Match Interrupt Enable" ] # [ inline ] pub fn cmpm5 ( & mut self ) -> _CMPM5W { _CMPM5W { w : self } } # [ doc = "Bit 14 - Comparison 6 Match Interrupt Enable" ] # [ inline ] pub fn cmpm6 ( & mut self ) -> _CMPM6W { _CMPM6W { w : self } } # [ doc = "Bit 15 - Comparison 7 Match Interrupt Enable" ] # [ inline ] pub fn cmpm7 ( & mut self ) -> _CMPM7W { _CMPM7W { w : self } } # [ doc = "Bit 16 - Comparison 0 Update Interrupt Enable" ] # [ inline ] pub fn cmpu0 ( & mut self ) -> _CMPU0W { _CMPU0W { w : self } } # [ doc = "Bit 17 - Comparison 1 Update Interrupt Enable" ] # [ inline ] pub fn cmpu1 ( & mut self ) -> _CMPU1W { _CMPU1W { w : self } } # [ doc = "Bit 18 - Comparison 2 Update Interrupt Enable" ] # [ inline ] pub fn cmpu2 ( & mut self ) -> _CMPU2W { _CMPU2W { w : self } } # [ doc = "Bit 19 - Comparison 3 Update Interrupt Enable" ] # [ inline ] pub fn cmpu3 ( & mut self ) -> _CMPU3W { _CMPU3W { w : self } } # [ doc = "Bit 20 - Comparison 4 Update Interrupt Enable" ] # [ inline ] pub fn cmpu4 ( & mut self ) -> _CMPU4W { _CMPU4W { w : self } } # [ doc = "Bit 21 - Comparison 5 Update Interrupt Enable" ] # [ inline ] pub fn cmpu5 ( & mut self ) -> _CMPU5W { _CMPU5W { w : self } } # [ doc = "Bit 22 - Comparison 6 Update Interrupt Enable" ] # [ inline ] pub fn cmpu6 ( & mut self ) -> _CMPU6W { _CMPU6W { w : self } } # [ doc = "Bit 23 - Comparison 7 Update Interrupt Enable" ] # [ inline ] pub fn cmpu7 ( & mut self ) -> _CMPU7W { _CMPU7W { w : self } } } } # [ doc = "PWM Interrupt Disable Register 2" ] pub struct IDR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Disable Register 2" ] pub mod idr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _WRDYW < 'a > { w : & 'a mut W , } impl < 'a > _WRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM0W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM1W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM2W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM3W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM4W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM5W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM6W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPM7W < 'a > { w : & 'a mut W , } impl < 'a > _CMPM7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU0W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU1W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU2W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU3W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU4W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU5W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU6W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPU7W < 'a > { w : & 'a mut W , } impl < 'a > _CMPU7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Write Ready for Synchronous Channels Update Interrupt Disable" ] # [ inline ] pub fn wrdy ( & mut self ) -> _WRDYW { _WRDYW { w : self } } # [ doc = "Bit 1 - PDC End of TX Buffer Interrupt Disable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 2 - PDC TX Buffer Empty Interrupt Disable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 3 - Synchronous Channels Update Underrun Error Interrupt Disable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 8 - Comparison 0 Match Interrupt Disable" ] # [ inline ] pub fn cmpm0 ( & mut self ) -> _CMPM0W { _CMPM0W { w : self } } # [ doc = "Bit 9 - Comparison 1 Match Interrupt Disable" ] # [ inline ] pub fn cmpm1 ( & mut self ) -> _CMPM1W { _CMPM1W { w : self } } # [ doc = "Bit 10 - Comparison 2 Match Interrupt Disable" ] # [ inline ] pub fn cmpm2 ( & mut self ) -> _CMPM2W { _CMPM2W { w : self } } # [ doc = "Bit 11 - Comparison 3 Match Interrupt Disable" ] # [ inline ] pub fn cmpm3 ( & mut self ) -> _CMPM3W { _CMPM3W { w : self } } # [ doc = "Bit 12 - Comparison 4 Match Interrupt Disable" ] # [ inline ] pub fn cmpm4 ( & mut self ) -> _CMPM4W { _CMPM4W { w : self } } # [ doc = "Bit 13 - Comparison 5 Match Interrupt Disable" ] # [ inline ] pub fn cmpm5 ( & mut self ) -> _CMPM5W { _CMPM5W { w : self } } # [ doc = "Bit 14 - Comparison 6 Match Interrupt Disable" ] # [ inline ] pub fn cmpm6 ( & mut self ) -> _CMPM6W { _CMPM6W { w : self } } # [ doc = "Bit 15 - Comparison 7 Match Interrupt Disable" ] # [ inline ] pub fn cmpm7 ( & mut self ) -> _CMPM7W { _CMPM7W { w : self } } # [ doc = "Bit 16 - Comparison 0 Update Interrupt Disable" ] # [ inline ] pub fn cmpu0 ( & mut self ) -> _CMPU0W { _CMPU0W { w : self } } # [ doc = "Bit 17 - Comparison 1 Update Interrupt Disable" ] # [ inline ] pub fn cmpu1 ( & mut self ) -> _CMPU1W { _CMPU1W { w : self } } # [ doc = "Bit 18 - Comparison 2 Update Interrupt Disable" ] # [ inline ] pub fn cmpu2 ( & mut self ) -> _CMPU2W { _CMPU2W { w : self } } # [ doc = "Bit 19 - Comparison 3 Update Interrupt Disable" ] # [ inline ] pub fn cmpu3 ( & mut self ) -> _CMPU3W { _CMPU3W { w : self } } # [ doc = "Bit 20 - Comparison 4 Update Interrupt Disable" ] # [ inline ] pub fn cmpu4 ( & mut self ) -> _CMPU4W { _CMPU4W { w : self } } # [ doc = "Bit 21 - Comparison 5 Update Interrupt Disable" ] # [ inline ] pub fn cmpu5 ( & mut self ) -> _CMPU5W { _CMPU5W { w : self } } # [ doc = "Bit 22 - Comparison 6 Update Interrupt Disable" ] # [ inline ] pub fn cmpu6 ( & mut self ) -> _CMPU6W { _CMPU6W { w : self } } # [ doc = "Bit 23 - Comparison 7 Update Interrupt Disable" ] # [ inline ] pub fn cmpu7 ( & mut self ) -> _CMPU7W { _CMPU7W { w : self } } } } # [ doc = "PWM Interrupt Mask Register 2" ] pub struct IMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Mask Register 2" ] pub mod imr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR2 { # [ 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 WRDYR { bits : bool , } impl WRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM0R { bits : bool , } impl CMPM0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM1R { bits : bool , } impl CMPM1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM2R { bits : bool , } impl CMPM2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM3R { bits : bool , } impl CMPM3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM4R { bits : bool , } impl CMPM4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM5R { bits : bool , } impl CMPM5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM6R { bits : bool , } impl CMPM6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM7R { bits : bool , } impl CMPM7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU0R { bits : bool , } impl CMPU0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU1R { bits : bool , } impl CMPU1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU2R { bits : bool , } impl CMPU2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU3R { bits : bool , } impl CMPU3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU4R { bits : bool , } impl CMPU4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU5R { bits : bool , } impl CMPU5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU6R { bits : bool , } impl CMPU6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU7R { bits : bool , } impl CMPU7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Write Ready for Synchronous Channels Update Interrupt Mask" ] # [ inline ] pub fn wrdy ( & self ) -> WRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WRDYR { bits } } # [ doc = "Bit 1 - PDC End of TX Buffer Interrupt Mask" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 2 - PDC TX Buffer Empty Interrupt Mask" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 3 - Synchronous Channels Update Underrun Error Interrupt Mask" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 8 - Comparison 0 Match Interrupt Mask" ] # [ inline ] pub fn cmpm0 ( & self ) -> CMPM0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM0R { bits } } # [ doc = "Bit 9 - Comparison 1 Match Interrupt Mask" ] # [ inline ] pub fn cmpm1 ( & self ) -> CMPM1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM1R { bits } } # [ doc = "Bit 10 - Comparison 2 Match Interrupt Mask" ] # [ inline ] pub fn cmpm2 ( & self ) -> CMPM2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM2R { bits } } # [ doc = "Bit 11 - Comparison 3 Match Interrupt Mask" ] # [ inline ] pub fn cmpm3 ( & self ) -> CMPM3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM3R { bits } } # [ doc = "Bit 12 - Comparison 4 Match Interrupt Mask" ] # [ inline ] pub fn cmpm4 ( & self ) -> CMPM4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM4R { bits } } # [ doc = "Bit 13 - Comparison 5 Match Interrupt Mask" ] # [ inline ] pub fn cmpm5 ( & self ) -> CMPM5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM5R { bits } } # [ doc = "Bit 14 - Comparison 6 Match Interrupt Mask" ] # [ inline ] pub fn cmpm6 ( & self ) -> CMPM6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM6R { bits } } # [ doc = "Bit 15 - Comparison 7 Match Interrupt Mask" ] # [ inline ] pub fn cmpm7 ( & self ) -> CMPM7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM7R { bits } } # [ doc = "Bit 16 - Comparison 0 Update Interrupt Mask" ] # [ inline ] pub fn cmpu0 ( & self ) -> CMPU0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU0R { bits } } # [ doc = "Bit 17 - Comparison 1 Update Interrupt Mask" ] # [ inline ] pub fn cmpu1 ( & self ) -> CMPU1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU1R { bits } } # [ doc = "Bit 18 - Comparison 2 Update Interrupt Mask" ] # [ inline ] pub fn cmpu2 ( & self ) -> CMPU2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU2R { bits } } # [ doc = "Bit 19 - Comparison 3 Update Interrupt Mask" ] # [ inline ] pub fn cmpu3 ( & self ) -> CMPU3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU3R { bits } } # [ doc = "Bit 20 - Comparison 4 Update Interrupt Mask" ] # [ inline ] pub fn cmpu4 ( & self ) -> CMPU4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU4R { bits } } # [ doc = "Bit 21 - Comparison 5 Update Interrupt Mask" ] # [ inline ] pub fn cmpu5 ( & self ) -> CMPU5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU5R { bits } } # [ doc = "Bit 22 - Comparison 6 Update Interrupt Mask" ] # [ inline ] pub fn cmpu6 ( & self ) -> CMPU6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU6R { bits } } # [ doc = "Bit 23 - Comparison 7 Update Interrupt Mask" ] # [ inline ] pub fn cmpu7 ( & self ) -> CMPU7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU7R { bits } } } } # [ doc = "PWM Interrupt Status Register 2" ] pub struct ISR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Interrupt Status Register 2" ] pub mod isr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ISR2 { # [ 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 WRDYR { bits : bool , } impl WRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM0R { bits : bool , } impl CMPM0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM1R { bits : bool , } impl CMPM1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM2R { bits : bool , } impl CMPM2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM3R { bits : bool , } impl CMPM3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM4R { bits : bool , } impl CMPM4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM5R { bits : bool , } impl CMPM5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM6R { bits : bool , } impl CMPM6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPM7R { bits : bool , } impl CMPM7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU0R { bits : bool , } impl CMPU0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU1R { bits : bool , } impl CMPU1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU2R { bits : bool , } impl CMPU2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU3R { bits : bool , } impl CMPU3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU4R { bits : bool , } impl CMPU4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU5R { bits : bool , } impl CMPU5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU6R { bits : bool , } impl CMPU6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPU7R { bits : bool , } impl CMPU7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Write Ready for Synchronous Channels Update" ] # [ inline ] pub fn wrdy ( & self ) -> WRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WRDYR { bits } } # [ doc = "Bit 1 - PDC End of TX Buffer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 2 - PDC TX Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 3 - Synchronous Channels Update Underrun Error" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 8 - Comparison 0 Match" ] # [ inline ] pub fn cmpm0 ( & self ) -> CMPM0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM0R { bits } } # [ doc = "Bit 9 - Comparison 1 Match" ] # [ inline ] pub fn cmpm1 ( & self ) -> CMPM1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM1R { bits } } # [ doc = "Bit 10 - Comparison 2 Match" ] # [ inline ] pub fn cmpm2 ( & self ) -> CMPM2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM2R { bits } } # [ doc = "Bit 11 - Comparison 3 Match" ] # [ inline ] pub fn cmpm3 ( & self ) -> CMPM3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM3R { bits } } # [ doc = "Bit 12 - Comparison 4 Match" ] # [ inline ] pub fn cmpm4 ( & self ) -> CMPM4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM4R { bits } } # [ doc = "Bit 13 - Comparison 5 Match" ] # [ inline ] pub fn cmpm5 ( & self ) -> CMPM5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM5R { bits } } # [ doc = "Bit 14 - Comparison 6 Match" ] # [ inline ] pub fn cmpm6 ( & self ) -> CMPM6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM6R { bits } } # [ doc = "Bit 15 - Comparison 7 Match" ] # [ inline ] pub fn cmpm7 ( & self ) -> CMPM7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPM7R { bits } } # [ doc = "Bit 16 - Comparison 0 Update" ] # [ inline ] pub fn cmpu0 ( & self ) -> CMPU0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU0R { bits } } # [ doc = "Bit 17 - Comparison 1 Update" ] # [ inline ] pub fn cmpu1 ( & self ) -> CMPU1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU1R { bits } } # [ doc = "Bit 18 - Comparison 2 Update" ] # [ inline ] pub fn cmpu2 ( & self ) -> CMPU2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU2R { bits } } # [ doc = "Bit 19 - Comparison 3 Update" ] # [ inline ] pub fn cmpu3 ( & self ) -> CMPU3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU3R { bits } } # [ doc = "Bit 20 - Comparison 4 Update" ] # [ inline ] pub fn cmpu4 ( & self ) -> CMPU4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU4R { bits } } # [ doc = "Bit 21 - Comparison 5 Update" ] # [ inline ] pub fn cmpu5 ( & self ) -> CMPU5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU5R { bits } } # [ doc = "Bit 22 - Comparison 6 Update" ] # [ inline ] pub fn cmpu6 ( & self ) -> CMPU6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU6R { bits } } # [ doc = "Bit 23 - Comparison 7 Update" ] # [ inline ] pub fn cmpu7 ( & self ) -> CMPU7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPU7R { bits } } } } # [ doc = "PWM Output Override Value Register" ] pub struct OOV { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Output Override Value Register" ] pub mod oov { # [ 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 :: OOV { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 OOVH0R { bits : bool , } impl OOVH0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVH1R { bits : bool , } impl OOVH1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVH2R { bits : bool , } impl OOVH2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVH3R { bits : bool , } impl OOVH3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVH4R { bits : bool , } impl OOVH4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVH5R { bits : bool , } impl OOVH5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVH6R { bits : bool , } impl OOVH6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVH7R { bits : bool , } impl OOVH7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL0R { bits : bool , } impl OOVL0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL1R { bits : bool , } impl OOVL1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL2R { bits : bool , } impl OOVL2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL3R { bits : bool , } impl OOVL3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL4R { bits : bool , } impl OOVL4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL5R { bits : bool , } impl OOVL5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL6R { bits : bool , } impl OOVL6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OOVL7R { bits : bool , } impl OOVL7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _OOVH0W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVH1W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVH2W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVH3W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVH4W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVH5W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVH6W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVH7W < 'a > { w : & 'a mut W , } impl < 'a > _OOVH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL0W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL1W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL2W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL3W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL4W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL5W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL6W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OOVL7W < 'a > { w : & 'a mut W , } impl < 'a > _OOVL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Output Override Value for PWMH output of the channel 0" ] # [ inline ] pub fn oovh0 ( & self ) -> OOVH0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH0R { bits } } # [ doc = "Bit 1 - Output Override Value for PWMH output of the channel 1" ] # [ inline ] pub fn oovh1 ( & self ) -> OOVH1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH1R { bits } } # [ doc = "Bit 2 - Output Override Value for PWMH output of the channel 2" ] # [ inline ] pub fn oovh2 ( & self ) -> OOVH2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH2R { bits } } # [ doc = "Bit 3 - Output Override Value for PWMH output of the channel 3" ] # [ inline ] pub fn oovh3 ( & self ) -> OOVH3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH3R { bits } } # [ doc = "Bit 4 - Output Override Value for PWMH output of the channel 4" ] # [ inline ] pub fn oovh4 ( & self ) -> OOVH4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH4R { bits } } # [ doc = "Bit 5 - Output Override Value for PWMH output of the channel 5" ] # [ inline ] pub fn oovh5 ( & self ) -> OOVH5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH5R { bits } } # [ doc = "Bit 6 - Output Override Value for PWMH output of the channel 6" ] # [ inline ] pub fn oovh6 ( & self ) -> OOVH6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH6R { bits } } # [ doc = "Bit 7 - Output Override Value for PWMH output of the channel 7" ] # [ inline ] pub fn oovh7 ( & self ) -> OOVH7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVH7R { bits } } # [ doc = "Bit 16 - Output Override Value for PWML output of the channel 0" ] # [ inline ] pub fn oovl0 ( & self ) -> OOVL0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL0R { bits } } # [ doc = "Bit 17 - Output Override Value for PWML output of the channel 1" ] # [ inline ] pub fn oovl1 ( & self ) -> OOVL1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL1R { bits } } # [ doc = "Bit 18 - Output Override Value for PWML output of the channel 2" ] # [ inline ] pub fn oovl2 ( & self ) -> OOVL2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL2R { bits } } # [ doc = "Bit 19 - Output Override Value for PWML output of the channel 3" ] # [ inline ] pub fn oovl3 ( & self ) -> OOVL3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL3R { bits } } # [ doc = "Bit 20 - Output Override Value for PWML output of the channel 4" ] # [ inline ] pub fn oovl4 ( & self ) -> OOVL4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL4R { bits } } # [ doc = "Bit 21 - Output Override Value for PWML output of the channel 5" ] # [ inline ] pub fn oovl5 ( & self ) -> OOVL5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL5R { bits } } # [ doc = "Bit 22 - Output Override Value for PWML output of the channel 6" ] # [ inline ] pub fn oovl6 ( & self ) -> OOVL6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL6R { bits } } # [ doc = "Bit 23 - Output Override Value for PWML output of the channel 7" ] # [ inline ] pub fn oovl7 ( & self ) -> OOVL7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OOVL7R { 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 - Output Override Value for PWMH output of the channel 0" ] # [ inline ] pub fn oovh0 ( & mut self ) -> _OOVH0W { _OOVH0W { w : self } } # [ doc = "Bit 1 - Output Override Value for PWMH output of the channel 1" ] # [ inline ] pub fn oovh1 ( & mut self ) -> _OOVH1W { _OOVH1W { w : self } } # [ doc = "Bit 2 - Output Override Value for PWMH output of the channel 2" ] # [ inline ] pub fn oovh2 ( & mut self ) -> _OOVH2W { _OOVH2W { w : self } } # [ doc = "Bit 3 - Output Override Value for PWMH output of the channel 3" ] # [ inline ] pub fn oovh3 ( & mut self ) -> _OOVH3W { _OOVH3W { w : self } } # [ doc = "Bit 4 - Output Override Value for PWMH output of the channel 4" ] # [ inline ] pub fn oovh4 ( & mut self ) -> _OOVH4W { _OOVH4W { w : self } } # [ doc = "Bit 5 - Output Override Value for PWMH output of the channel 5" ] # [ inline ] pub fn oovh5 ( & mut self ) -> _OOVH5W { _OOVH5W { w : self } } # [ doc = "Bit 6 - Output Override Value for PWMH output of the channel 6" ] # [ inline ] pub fn oovh6 ( & mut self ) -> _OOVH6W { _OOVH6W { w : self } } # [ doc = "Bit 7 - Output Override Value for PWMH output of the channel 7" ] # [ inline ] pub fn oovh7 ( & mut self ) -> _OOVH7W { _OOVH7W { w : self } } # [ doc = "Bit 16 - Output Override Value for PWML output of the channel 0" ] # [ inline ] pub fn oovl0 ( & mut self ) -> _OOVL0W { _OOVL0W { w : self } } # [ doc = "Bit 17 - Output Override Value for PWML output of the channel 1" ] # [ inline ] pub fn oovl1 ( & mut self ) -> _OOVL1W { _OOVL1W { w : self } } # [ doc = "Bit 18 - Output Override Value for PWML output of the channel 2" ] # [ inline ] pub fn oovl2 ( & mut self ) -> _OOVL2W { _OOVL2W { w : self } } # [ doc = "Bit 19 - Output Override Value for PWML output of the channel 3" ] # [ inline ] pub fn oovl3 ( & mut self ) -> _OOVL3W { _OOVL3W { w : self } } # [ doc = "Bit 20 - Output Override Value for PWML output of the channel 4" ] # [ inline ] pub fn oovl4 ( & mut self ) -> _OOVL4W { _OOVL4W { w : self } } # [ doc = "Bit 21 - Output Override Value for PWML output of the channel 5" ] # [ inline ] pub fn oovl5 ( & mut self ) -> _OOVL5W { _OOVL5W { w : self } } # [ doc = "Bit 22 - Output Override Value for PWML output of the channel 6" ] # [ inline ] pub fn oovl6 ( & mut self ) -> _OOVL6W { _OOVL6W { w : self } } # [ doc = "Bit 23 - Output Override Value for PWML output of the channel 7" ] # [ inline ] pub fn oovl7 ( & mut self ) -> _OOVL7W { _OOVL7W { w : self } } } } # [ doc = "PWM Output Selection Register" ] pub struct OS { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Output Selection Register" ] pub mod os { # [ 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 :: OS { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 OSH0R { bits : bool , } impl OSH0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSH1R { bits : bool , } impl OSH1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSH2R { bits : bool , } impl OSH2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSH3R { bits : bool , } impl OSH3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSH4R { bits : bool , } impl OSH4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSH5R { bits : bool , } impl OSH5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSH6R { bits : bool , } impl OSH6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSH7R { bits : bool , } impl OSH7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL0R { bits : bool , } impl OSL0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL1R { bits : bool , } impl OSL1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL2R { bits : bool , } impl OSL2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL3R { bits : bool , } impl OSL3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL4R { bits : bool , } impl OSL4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL5R { bits : bool , } impl OSL5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL6R { bits : bool , } impl OSL6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSL7R { bits : bool , } impl OSL7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _OSH0W < 'a > { w : & 'a mut W , } impl < 'a > _OSH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSH1W < 'a > { w : & 'a mut W , } impl < 'a > _OSH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSH2W < 'a > { w : & 'a mut W , } impl < 'a > _OSH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSH3W < 'a > { w : & 'a mut W , } impl < 'a > _OSH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSH4W < 'a > { w : & 'a mut W , } impl < 'a > _OSH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSH5W < 'a > { w : & 'a mut W , } impl < 'a > _OSH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSH6W < 'a > { w : & 'a mut W , } impl < 'a > _OSH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSH7W < 'a > { w : & 'a mut W , } impl < 'a > _OSH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL0W < 'a > { w : & 'a mut W , } impl < 'a > _OSL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL1W < 'a > { w : & 'a mut W , } impl < 'a > _OSL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL2W < 'a > { w : & 'a mut W , } impl < 'a > _OSL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL3W < 'a > { w : & 'a mut W , } impl < 'a > _OSL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL4W < 'a > { w : & 'a mut W , } impl < 'a > _OSL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL5W < 'a > { w : & 'a mut W , } impl < 'a > _OSL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL6W < 'a > { w : & 'a mut W , } impl < 'a > _OSL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSL7W < 'a > { w : & 'a mut W , } impl < 'a > _OSL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Output Selection for PWMH output of the channel 0" ] # [ inline ] pub fn osh0 ( & self ) -> OSH0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH0R { bits } } # [ doc = "Bit 1 - Output Selection for PWMH output of the channel 1" ] # [ inline ] pub fn osh1 ( & self ) -> OSH1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH1R { bits } } # [ doc = "Bit 2 - Output Selection for PWMH output of the channel 2" ] # [ inline ] pub fn osh2 ( & self ) -> OSH2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH2R { bits } } # [ doc = "Bit 3 - Output Selection for PWMH output of the channel 3" ] # [ inline ] pub fn osh3 ( & self ) -> OSH3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH3R { bits } } # [ doc = "Bit 4 - Output Selection for PWMH output of the channel 4" ] # [ inline ] pub fn osh4 ( & self ) -> OSH4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH4R { bits } } # [ doc = "Bit 5 - Output Selection for PWMH output of the channel 5" ] # [ inline ] pub fn osh5 ( & self ) -> OSH5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH5R { bits } } # [ doc = "Bit 6 - Output Selection for PWMH output of the channel 6" ] # [ inline ] pub fn osh6 ( & self ) -> OSH6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH6R { bits } } # [ doc = "Bit 7 - Output Selection for PWMH output of the channel 7" ] # [ inline ] pub fn osh7 ( & self ) -> OSH7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSH7R { bits } } # [ doc = "Bit 16 - Output Selection for PWML output of the channel 0" ] # [ inline ] pub fn osl0 ( & self ) -> OSL0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL0R { bits } } # [ doc = "Bit 17 - Output Selection for PWML output of the channel 1" ] # [ inline ] pub fn osl1 ( & self ) -> OSL1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL1R { bits } } # [ doc = "Bit 18 - Output Selection for PWML output of the channel 2" ] # [ inline ] pub fn osl2 ( & self ) -> OSL2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL2R { bits } } # [ doc = "Bit 19 - Output Selection for PWML output of the channel 3" ] # [ inline ] pub fn osl3 ( & self ) -> OSL3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL3R { bits } } # [ doc = "Bit 20 - Output Selection for PWML output of the channel 4" ] # [ inline ] pub fn osl4 ( & self ) -> OSL4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL4R { bits } } # [ doc = "Bit 21 - Output Selection for PWML output of the channel 5" ] # [ inline ] pub fn osl5 ( & self ) -> OSL5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL5R { bits } } # [ doc = "Bit 22 - Output Selection for PWML output of the channel 6" ] # [ inline ] pub fn osl6 ( & self ) -> OSL6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL6R { bits } } # [ doc = "Bit 23 - Output Selection for PWML output of the channel 7" ] # [ inline ] pub fn osl7 ( & self ) -> OSL7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSL7R { 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 - Output Selection for PWMH output of the channel 0" ] # [ inline ] pub fn osh0 ( & mut self ) -> _OSH0W { _OSH0W { w : self } } # [ doc = "Bit 1 - Output Selection for PWMH output of the channel 1" ] # [ inline ] pub fn osh1 ( & mut self ) -> _OSH1W { _OSH1W { w : self } } # [ doc = "Bit 2 - Output Selection for PWMH output of the channel 2" ] # [ inline ] pub fn osh2 ( & mut self ) -> _OSH2W { _OSH2W { w : self } } # [ doc = "Bit 3 - Output Selection for PWMH output of the channel 3" ] # [ inline ] pub fn osh3 ( & mut self ) -> _OSH3W { _OSH3W { w : self } } # [ doc = "Bit 4 - Output Selection for PWMH output of the channel 4" ] # [ inline ] pub fn osh4 ( & mut self ) -> _OSH4W { _OSH4W { w : self } } # [ doc = "Bit 5 - Output Selection for PWMH output of the channel 5" ] # [ inline ] pub fn osh5 ( & mut self ) -> _OSH5W { _OSH5W { w : self } } # [ doc = "Bit 6 - Output Selection for PWMH output of the channel 6" ] # [ inline ] pub fn osh6 ( & mut self ) -> _OSH6W { _OSH6W { w : self } } # [ doc = "Bit 7 - Output Selection for PWMH output of the channel 7" ] # [ inline ] pub fn osh7 ( & mut self ) -> _OSH7W { _OSH7W { w : self } } # [ doc = "Bit 16 - Output Selection for PWML output of the channel 0" ] # [ inline ] pub fn osl0 ( & mut self ) -> _OSL0W { _OSL0W { w : self } } # [ doc = "Bit 17 - Output Selection for PWML output of the channel 1" ] # [ inline ] pub fn osl1 ( & mut self ) -> _OSL1W { _OSL1W { w : self } } # [ doc = "Bit 18 - Output Selection for PWML output of the channel 2" ] # [ inline ] pub fn osl2 ( & mut self ) -> _OSL2W { _OSL2W { w : self } } # [ doc = "Bit 19 - Output Selection for PWML output of the channel 3" ] # [ inline ] pub fn osl3 ( & mut self ) -> _OSL3W { _OSL3W { w : self } } # [ doc = "Bit 20 - Output Selection for PWML output of the channel 4" ] # [ inline ] pub fn osl4 ( & mut self ) -> _OSL4W { _OSL4W { w : self } } # [ doc = "Bit 21 - Output Selection for PWML output of the channel 5" ] # [ inline ] pub fn osl5 ( & mut self ) -> _OSL5W { _OSL5W { w : self } } # [ doc = "Bit 22 - Output Selection for PWML output of the channel 6" ] # [ inline ] pub fn osl6 ( & mut self ) -> _OSL6W { _OSL6W { w : self } } # [ doc = "Bit 23 - Output Selection for PWML output of the channel 7" ] # [ inline ] pub fn osl7 ( & mut self ) -> _OSL7W { _OSL7W { w : self } } } } # [ doc = "PWM Output Selection Set Register" ] pub struct OSS { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Output Selection Set Register" ] pub mod oss { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OSS { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _OSSH0W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSH1W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSH2W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSH3W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSH4W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSH5W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSH6W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSH7W < 'a > { w : & 'a mut W , } impl < 'a > _OSSH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL0W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL1W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL2W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL3W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL4W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL5W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL6W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSL7W < 'a > { w : & 'a mut W , } impl < 'a > _OSSL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Selection Set for PWMH output of the channel 0" ] # [ inline ] pub fn ossh0 ( & mut self ) -> _OSSH0W { _OSSH0W { w : self } } # [ doc = "Bit 1 - Output Selection Set for PWMH output of the channel 1" ] # [ inline ] pub fn ossh1 ( & mut self ) -> _OSSH1W { _OSSH1W { w : self } } # [ doc = "Bit 2 - Output Selection Set for PWMH output of the channel 2" ] # [ inline ] pub fn ossh2 ( & mut self ) -> _OSSH2W { _OSSH2W { w : self } } # [ doc = "Bit 3 - Output Selection Set for PWMH output of the channel 3" ] # [ inline ] pub fn ossh3 ( & mut self ) -> _OSSH3W { _OSSH3W { w : self } } # [ doc = "Bit 4 - Output Selection Set for PWMH output of the channel 4" ] # [ inline ] pub fn ossh4 ( & mut self ) -> _OSSH4W { _OSSH4W { w : self } } # [ doc = "Bit 5 - Output Selection Set for PWMH output of the channel 5" ] # [ inline ] pub fn ossh5 ( & mut self ) -> _OSSH5W { _OSSH5W { w : self } } # [ doc = "Bit 6 - Output Selection Set for PWMH output of the channel 6" ] # [ inline ] pub fn ossh6 ( & mut self ) -> _OSSH6W { _OSSH6W { w : self } } # [ doc = "Bit 7 - Output Selection Set for PWMH output of the channel 7" ] # [ inline ] pub fn ossh7 ( & mut self ) -> _OSSH7W { _OSSH7W { w : self } } # [ doc = "Bit 16 - Output Selection Set for PWML output of the channel 0" ] # [ inline ] pub fn ossl0 ( & mut self ) -> _OSSL0W { _OSSL0W { w : self } } # [ doc = "Bit 17 - Output Selection Set for PWML output of the channel 1" ] # [ inline ] pub fn ossl1 ( & mut self ) -> _OSSL1W { _OSSL1W { w : self } } # [ doc = "Bit 18 - Output Selection Set for PWML output of the channel 2" ] # [ inline ] pub fn ossl2 ( & mut self ) -> _OSSL2W { _OSSL2W { w : self } } # [ doc = "Bit 19 - Output Selection Set for PWML output of the channel 3" ] # [ inline ] pub fn ossl3 ( & mut self ) -> _OSSL3W { _OSSL3W { w : self } } # [ doc = "Bit 20 - Output Selection Set for PWML output of the channel 4" ] # [ inline ] pub fn ossl4 ( & mut self ) -> _OSSL4W { _OSSL4W { w : self } } # [ doc = "Bit 21 - Output Selection Set for PWML output of the channel 5" ] # [ inline ] pub fn ossl5 ( & mut self ) -> _OSSL5W { _OSSL5W { w : self } } # [ doc = "Bit 22 - Output Selection Set for PWML output of the channel 6" ] # [ inline ] pub fn ossl6 ( & mut self ) -> _OSSL6W { _OSSL6W { w : self } } # [ doc = "Bit 23 - Output Selection Set for PWML output of the channel 7" ] # [ inline ] pub fn ossl7 ( & mut self ) -> _OSSL7W { _OSSL7W { w : self } } } } # [ doc = "PWM Output Selection Clear Register" ] pub struct OSC { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Output Selection Clear Register" ] pub mod osc { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OSC { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _OSCH0W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCH1W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCH2W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCH3W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCH4W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCH5W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCH6W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCH7W < 'a > { w : & 'a mut W , } impl < 'a > _OSCH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL0W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL1W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL2W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL3W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL4W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL5W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL6W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCL7W < 'a > { w : & 'a mut W , } impl < 'a > _OSCL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Selection Clear for PWMH output of the channel 0" ] # [ inline ] pub fn osch0 ( & mut self ) -> _OSCH0W { _OSCH0W { w : self } } # [ doc = "Bit 1 - Output Selection Clear for PWMH output of the channel 1" ] # [ inline ] pub fn osch1 ( & mut self ) -> _OSCH1W { _OSCH1W { w : self } } # [ doc = "Bit 2 - Output Selection Clear for PWMH output of the channel 2" ] # [ inline ] pub fn osch2 ( & mut self ) -> _OSCH2W { _OSCH2W { w : self } } # [ doc = "Bit 3 - Output Selection Clear for PWMH output of the channel 3" ] # [ inline ] pub fn osch3 ( & mut self ) -> _OSCH3W { _OSCH3W { w : self } } # [ doc = "Bit 4 - Output Selection Clear for PWMH output of the channel 4" ] # [ inline ] pub fn osch4 ( & mut self ) -> _OSCH4W { _OSCH4W { w : self } } # [ doc = "Bit 5 - Output Selection Clear for PWMH output of the channel 5" ] # [ inline ] pub fn osch5 ( & mut self ) -> _OSCH5W { _OSCH5W { w : self } } # [ doc = "Bit 6 - Output Selection Clear for PWMH output of the channel 6" ] # [ inline ] pub fn osch6 ( & mut self ) -> _OSCH6W { _OSCH6W { w : self } } # [ doc = "Bit 7 - Output Selection Clear for PWMH output of the channel 7" ] # [ inline ] pub fn osch7 ( & mut self ) -> _OSCH7W { _OSCH7W { w : self } } # [ doc = "Bit 16 - Output Selection Clear for PWML output of the channel 0" ] # [ inline ] pub fn oscl0 ( & mut self ) -> _OSCL0W { _OSCL0W { w : self } } # [ doc = "Bit 17 - Output Selection Clear for PWML output of the channel 1" ] # [ inline ] pub fn oscl1 ( & mut self ) -> _OSCL1W { _OSCL1W { w : self } } # [ doc = "Bit 18 - Output Selection Clear for PWML output of the channel 2" ] # [ inline ] pub fn oscl2 ( & mut self ) -> _OSCL2W { _OSCL2W { w : self } } # [ doc = "Bit 19 - Output Selection Clear for PWML output of the channel 3" ] # [ inline ] pub fn oscl3 ( & mut self ) -> _OSCL3W { _OSCL3W { w : self } } # [ doc = "Bit 20 - Output Selection Clear for PWML output of the channel 4" ] # [ inline ] pub fn oscl4 ( & mut self ) -> _OSCL4W { _OSCL4W { w : self } } # [ doc = "Bit 21 - Output Selection Clear for PWML output of the channel 5" ] # [ inline ] pub fn oscl5 ( & mut self ) -> _OSCL5W { _OSCL5W { w : self } } # [ doc = "Bit 22 - Output Selection Clear for PWML output of the channel 6" ] # [ inline ] pub fn oscl6 ( & mut self ) -> _OSCL6W { _OSCL6W { w : self } } # [ doc = "Bit 23 - Output Selection Clear for PWML output of the channel 7" ] # [ inline ] pub fn oscl7 ( & mut self ) -> _OSCL7W { _OSCL7W { w : self } } } } # [ doc = "PWM Output Selection Set Update Register" ] pub struct OSSUPD { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Output Selection Set Update Register" ] pub mod ossupd { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OSSUPD { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _OSSUPH0W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPH1W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPH2W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPH3W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPH4W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPH5W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPH6W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPH7W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL0W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL1W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL2W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL3W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL4W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL5W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL6W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSSUPL7W < 'a > { w : & 'a mut W , } impl < 'a > _OSSUPL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Selection Set for PWMH output of the channel 0" ] # [ inline ] pub fn ossuph0 ( & mut self ) -> _OSSUPH0W { _OSSUPH0W { w : self } } # [ doc = "Bit 1 - Output Selection Set for PWMH output of the channel 1" ] # [ inline ] pub fn ossuph1 ( & mut self ) -> _OSSUPH1W { _OSSUPH1W { w : self } } # [ doc = "Bit 2 - Output Selection Set for PWMH output of the channel 2" ] # [ inline ] pub fn ossuph2 ( & mut self ) -> _OSSUPH2W { _OSSUPH2W { w : self } } # [ doc = "Bit 3 - Output Selection Set for PWMH output of the channel 3" ] # [ inline ] pub fn ossuph3 ( & mut self ) -> _OSSUPH3W { _OSSUPH3W { w : self } } # [ doc = "Bit 4 - Output Selection Set for PWMH output of the channel 4" ] # [ inline ] pub fn ossuph4 ( & mut self ) -> _OSSUPH4W { _OSSUPH4W { w : self } } # [ doc = "Bit 5 - Output Selection Set for PWMH output of the channel 5" ] # [ inline ] pub fn ossuph5 ( & mut self ) -> _OSSUPH5W { _OSSUPH5W { w : self } } # [ doc = "Bit 6 - Output Selection Set for PWMH output of the channel 6" ] # [ inline ] pub fn ossuph6 ( & mut self ) -> _OSSUPH6W { _OSSUPH6W { w : self } } # [ doc = "Bit 7 - Output Selection Set for PWMH output of the channel 7" ] # [ inline ] pub fn ossuph7 ( & mut self ) -> _OSSUPH7W { _OSSUPH7W { w : self } } # [ doc = "Bit 16 - Output Selection Set for PWML output of the channel 0" ] # [ inline ] pub fn ossupl0 ( & mut self ) -> _OSSUPL0W { _OSSUPL0W { w : self } } # [ doc = "Bit 17 - Output Selection Set for PWML output of the channel 1" ] # [ inline ] pub fn ossupl1 ( & mut self ) -> _OSSUPL1W { _OSSUPL1W { w : self } } # [ doc = "Bit 18 - Output Selection Set for PWML output of the channel 2" ] # [ inline ] pub fn ossupl2 ( & mut self ) -> _OSSUPL2W { _OSSUPL2W { w : self } } # [ doc = "Bit 19 - Output Selection Set for PWML output of the channel 3" ] # [ inline ] pub fn ossupl3 ( & mut self ) -> _OSSUPL3W { _OSSUPL3W { w : self } } # [ doc = "Bit 20 - Output Selection Set for PWML output of the channel 4" ] # [ inline ] pub fn ossupl4 ( & mut self ) -> _OSSUPL4W { _OSSUPL4W { w : self } } # [ doc = "Bit 21 - Output Selection Set for PWML output of the channel 5" ] # [ inline ] pub fn ossupl5 ( & mut self ) -> _OSSUPL5W { _OSSUPL5W { w : self } } # [ doc = "Bit 22 - Output Selection Set for PWML output of the channel 6" ] # [ inline ] pub fn ossupl6 ( & mut self ) -> _OSSUPL6W { _OSSUPL6W { w : self } } # [ doc = "Bit 23 - Output Selection Set for PWML output of the channel 7" ] # [ inline ] pub fn ossupl7 ( & mut self ) -> _OSSUPL7W { _OSSUPL7W { w : self } } } } # [ doc = "PWM Output Selection Clear Update Register" ] pub struct OSCUPD { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Output Selection Clear Update Register" ] pub mod oscupd { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OSCUPD { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _OSCUPH0W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPH1W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPH2W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPH3W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPH4W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPH5W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPH6W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPH7W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL0W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL1W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL2W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL3W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL4W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL5W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL6W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OSCUPL7W < 'a > { w : & 'a mut W , } impl < 'a > _OSCUPL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Selection Clear for PWMH output of the channel 0" ] # [ inline ] pub fn oscuph0 ( & mut self ) -> _OSCUPH0W { _OSCUPH0W { w : self } } # [ doc = "Bit 1 - Output Selection Clear for PWMH output of the channel 1" ] # [ inline ] pub fn oscuph1 ( & mut self ) -> _OSCUPH1W { _OSCUPH1W { w : self } } # [ doc = "Bit 2 - Output Selection Clear for PWMH output of the channel 2" ] # [ inline ] pub fn oscuph2 ( & mut self ) -> _OSCUPH2W { _OSCUPH2W { w : self } } # [ doc = "Bit 3 - Output Selection Clear for PWMH output of the channel 3" ] # [ inline ] pub fn oscuph3 ( & mut self ) -> _OSCUPH3W { _OSCUPH3W { w : self } } # [ doc = "Bit 4 - Output Selection Clear for PWMH output of the channel 4" ] # [ inline ] pub fn oscuph4 ( & mut self ) -> _OSCUPH4W { _OSCUPH4W { w : self } } # [ doc = "Bit 5 - Output Selection Clear for PWMH output of the channel 5" ] # [ inline ] pub fn oscuph5 ( & mut self ) -> _OSCUPH5W { _OSCUPH5W { w : self } } # [ doc = "Bit 6 - Output Selection Clear for PWMH output of the channel 6" ] # [ inline ] pub fn oscuph6 ( & mut self ) -> _OSCUPH6W { _OSCUPH6W { w : self } } # [ doc = "Bit 7 - Output Selection Clear for PWMH output of the channel 7" ] # [ inline ] pub fn oscuph7 ( & mut self ) -> _OSCUPH7W { _OSCUPH7W { w : self } } # [ doc = "Bit 16 - Output Selection Clear for PWML output of the channel 0" ] # [ inline ] pub fn oscupl0 ( & mut self ) -> _OSCUPL0W { _OSCUPL0W { w : self } } # [ doc = "Bit 17 - Output Selection Clear for PWML output of the channel 1" ] # [ inline ] pub fn oscupl1 ( & mut self ) -> _OSCUPL1W { _OSCUPL1W { w : self } } # [ doc = "Bit 18 - Output Selection Clear for PWML output of the channel 2" ] # [ inline ] pub fn oscupl2 ( & mut self ) -> _OSCUPL2W { _OSCUPL2W { w : self } } # [ doc = "Bit 19 - Output Selection Clear for PWML output of the channel 3" ] # [ inline ] pub fn oscupl3 ( & mut self ) -> _OSCUPL3W { _OSCUPL3W { w : self } } # [ doc = "Bit 20 - Output Selection Clear for PWML output of the channel 4" ] # [ inline ] pub fn oscupl4 ( & mut self ) -> _OSCUPL4W { _OSCUPL4W { w : self } } # [ doc = "Bit 21 - Output Selection Clear for PWML output of the channel 5" ] # [ inline ] pub fn oscupl5 ( & mut self ) -> _OSCUPL5W { _OSCUPL5W { w : self } } # [ doc = "Bit 22 - Output Selection Clear for PWML output of the channel 6" ] # [ inline ] pub fn oscupl6 ( & mut self ) -> _OSCUPL6W { _OSCUPL6W { w : self } } # [ doc = "Bit 23 - Output Selection Clear for PWML output of the channel 7" ] # [ inline ] pub fn oscupl7 ( & mut self ) -> _OSCUPL7W { _OSCUPL7W { w : self } } } } # [ doc = "PWM Fault Mode Register" ] pub struct FMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Fault Mode Register" ] pub mod fmr { # [ 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 :: FMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FPOLR { bits : u8 , } impl FPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FMODR { bits : u8 , } impl FMODR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FFILR { bits : u8 , } impl FFILR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _FPOLW < 'a > { w : & 'a mut W , } impl < 'a > _FPOLW < '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 _FMODW < 'a > { w : & 'a mut W , } impl < 'a > _FMODW < '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 _FFILW < 'a > { w : & 'a mut W , } impl < 'a > _FFILW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:7 - Fault Polarity (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpol ( & self ) -> FPOLR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPOLR { bits } } # [ doc = "Bits 8:15 - Fault Activation Mode (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fmod ( & self ) -> FMODR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FMODR { bits } } # [ doc = "Bits 16:23 - Fault Filtering (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn ffil ( & self ) -> FFILR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FFILR { 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 - Fault Polarity (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpol ( & mut self ) -> _FPOLW { _FPOLW { w : self } } # [ doc = "Bits 8:15 - Fault Activation Mode (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fmod ( & mut self ) -> _FMODW { _FMODW { w : self } } # [ doc = "Bits 16:23 - Fault Filtering (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn ffil ( & mut self ) -> _FFILW { _FFILW { w : self } } } } # [ doc = "PWM Fault Status Register" ] pub struct FSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Fault Status Register" ] pub mod fsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FSR { # [ 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 FIVR { bits : u8 , } impl FIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FSR { bits : u8 , } impl FSR { # [ 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 - Fault Input Value (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fiv ( & self ) -> FIVR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FIVR { bits } } # [ doc = "Bits 8:15 - Fault Status (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fs ( & self ) -> FSR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FSR { bits } } } } # [ doc = "PWM Fault Clear Register" ] pub struct FCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Fault Clear Register" ] pub mod fcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: FCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _FCLRW < 'a > { w : & 'a mut W , } impl < 'a > _FCLRW < '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 = "Bits 0:7 - Fault Clear (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fclr ( & mut self ) -> _FCLRW { _FCLRW { w : self } } } } # [ doc = "PWM Fault Protection Value Register" ] pub struct FPV { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Fault Protection Value Register" ] pub mod fpv { # [ 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 :: FPV { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FPVH0R { bits : bool , } impl FPVH0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVH1R { bits : bool , } impl FPVH1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVH2R { bits : bool , } impl FPVH2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVH3R { bits : bool , } impl FPVH3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVH4R { bits : bool , } impl FPVH4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVH5R { bits : bool , } impl FPVH5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVH6R { bits : bool , } impl FPVH6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVH7R { bits : bool , } impl FPVH7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL0R { bits : bool , } impl FPVL0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL1R { bits : bool , } impl FPVL1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL2R { bits : bool , } impl FPVL2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL3R { bits : bool , } impl FPVL3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL4R { bits : bool , } impl FPVL4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL5R { bits : bool , } impl FPVL5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL6R { bits : bool , } impl FPVL6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FPVL7R { bits : bool , } impl FPVL7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _FPVH0W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVH1W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVH2W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVH3W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVH4W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVH5W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVH6W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVH7W < 'a > { w : & 'a mut W , } impl < 'a > _FPVH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL0W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL1W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL2W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL3W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL4W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL5W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL6W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FPVL7W < 'a > { w : & 'a mut W , } impl < 'a > _FPVL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Fault Protection Value for PWMH output on channel 0" ] # [ inline ] pub fn fpvh0 ( & self ) -> FPVH0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH0R { bits } } # [ doc = "Bit 1 - Fault Protection Value for PWMH output on channel 1" ] # [ inline ] pub fn fpvh1 ( & self ) -> FPVH1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH1R { bits } } # [ doc = "Bit 2 - Fault Protection Value for PWMH output on channel 2" ] # [ inline ] pub fn fpvh2 ( & self ) -> FPVH2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH2R { bits } } # [ doc = "Bit 3 - Fault Protection Value for PWMH output on channel 3" ] # [ inline ] pub fn fpvh3 ( & self ) -> FPVH3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH3R { bits } } # [ doc = "Bit 4 - Fault Protection Value for PWMH output on channel 4" ] # [ inline ] pub fn fpvh4 ( & self ) -> FPVH4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH4R { bits } } # [ doc = "Bit 5 - Fault Protection Value for PWMH output on channel 5" ] # [ inline ] pub fn fpvh5 ( & self ) -> FPVH5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH5R { bits } } # [ doc = "Bit 6 - Fault Protection Value for PWMH output on channel 6" ] # [ inline ] pub fn fpvh6 ( & self ) -> FPVH6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH6R { bits } } # [ doc = "Bit 7 - Fault Protection Value for PWMH output on channel 7" ] # [ inline ] pub fn fpvh7 ( & self ) -> FPVH7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVH7R { bits } } # [ doc = "Bit 16 - Fault Protection Value for PWML output on channel 0" ] # [ inline ] pub fn fpvl0 ( & self ) -> FPVL0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL0R { bits } } # [ doc = "Bit 17 - Fault Protection Value for PWML output on channel 1" ] # [ inline ] pub fn fpvl1 ( & self ) -> FPVL1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL1R { bits } } # [ doc = "Bit 18 - Fault Protection Value for PWML output on channel 2" ] # [ inline ] pub fn fpvl2 ( & self ) -> FPVL2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL2R { bits } } # [ doc = "Bit 19 - Fault Protection Value for PWML output on channel 3" ] # [ inline ] pub fn fpvl3 ( & self ) -> FPVL3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL3R { bits } } # [ doc = "Bit 20 - Fault Protection Value for PWML output on channel 4" ] # [ inline ] pub fn fpvl4 ( & self ) -> FPVL4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL4R { bits } } # [ doc = "Bit 21 - Fault Protection Value for PWML output on channel 5" ] # [ inline ] pub fn fpvl5 ( & self ) -> FPVL5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL5R { bits } } # [ doc = "Bit 22 - Fault Protection Value for PWML output on channel 6" ] # [ inline ] pub fn fpvl6 ( & self ) -> FPVL6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL6R { bits } } # [ doc = "Bit 23 - Fault Protection Value for PWML output on channel 7" ] # [ inline ] pub fn fpvl7 ( & self ) -> FPVL7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FPVL7R { 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 - Fault Protection Value for PWMH output on channel 0" ] # [ inline ] pub fn fpvh0 ( & mut self ) -> _FPVH0W { _FPVH0W { w : self } } # [ doc = "Bit 1 - Fault Protection Value for PWMH output on channel 1" ] # [ inline ] pub fn fpvh1 ( & mut self ) -> _FPVH1W { _FPVH1W { w : self } } # [ doc = "Bit 2 - Fault Protection Value for PWMH output on channel 2" ] # [ inline ] pub fn fpvh2 ( & mut self ) -> _FPVH2W { _FPVH2W { w : self } } # [ doc = "Bit 3 - Fault Protection Value for PWMH output on channel 3" ] # [ inline ] pub fn fpvh3 ( & mut self ) -> _FPVH3W { _FPVH3W { w : self } } # [ doc = "Bit 4 - Fault Protection Value for PWMH output on channel 4" ] # [ inline ] pub fn fpvh4 ( & mut self ) -> _FPVH4W { _FPVH4W { w : self } } # [ doc = "Bit 5 - Fault Protection Value for PWMH output on channel 5" ] # [ inline ] pub fn fpvh5 ( & mut self ) -> _FPVH5W { _FPVH5W { w : self } } # [ doc = "Bit 6 - Fault Protection Value for PWMH output on channel 6" ] # [ inline ] pub fn fpvh6 ( & mut self ) -> _FPVH6W { _FPVH6W { w : self } } # [ doc = "Bit 7 - Fault Protection Value for PWMH output on channel 7" ] # [ inline ] pub fn fpvh7 ( & mut self ) -> _FPVH7W { _FPVH7W { w : self } } # [ doc = "Bit 16 - Fault Protection Value for PWML output on channel 0" ] # [ inline ] pub fn fpvl0 ( & mut self ) -> _FPVL0W { _FPVL0W { w : self } } # [ doc = "Bit 17 - Fault Protection Value for PWML output on channel 1" ] # [ inline ] pub fn fpvl1 ( & mut self ) -> _FPVL1W { _FPVL1W { w : self } } # [ doc = "Bit 18 - Fault Protection Value for PWML output on channel 2" ] # [ inline ] pub fn fpvl2 ( & mut self ) -> _FPVL2W { _FPVL2W { w : self } } # [ doc = "Bit 19 - Fault Protection Value for PWML output on channel 3" ] # [ inline ] pub fn fpvl3 ( & mut self ) -> _FPVL3W { _FPVL3W { w : self } } # [ doc = "Bit 20 - Fault Protection Value for PWML output on channel 4" ] # [ inline ] pub fn fpvl4 ( & mut self ) -> _FPVL4W { _FPVL4W { w : self } } # [ doc = "Bit 21 - Fault Protection Value for PWML output on channel 5" ] # [ inline ] pub fn fpvl5 ( & mut self ) -> _FPVL5W { _FPVL5W { w : self } } # [ doc = "Bit 22 - Fault Protection Value for PWML output on channel 6" ] # [ inline ] pub fn fpvl6 ( & mut self ) -> _FPVL6W { _FPVL6W { w : self } } # [ doc = "Bit 23 - Fault Protection Value for PWML output on channel 7" ] # [ inline ] pub fn fpvl7 ( & mut self ) -> _FPVL7W { _FPVL7W { w : self } } } } # [ doc = "PWM Fault Protection Enable Register 1" ] pub struct FPE1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Fault Protection Enable Register 1" ] pub mod fpe1 { # [ 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 :: FPE1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FPE0R { bits : u8 , } impl FPE0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FPE1R { bits : u8 , } impl FPE1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FPE2R { bits : u8 , } impl FPE2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FPE3R { bits : u8 , } impl FPE3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _FPE0W < 'a > { w : & 'a mut W , } impl < 'a > _FPE0W < '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 _FPE1W < 'a > { w : & 'a mut W , } impl < 'a > _FPE1W < '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 _FPE2W < 'a > { w : & 'a mut W , } impl < 'a > _FPE2W < '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 _FPE3W < 'a > { w : & 'a mut W , } impl < 'a > _FPE3W < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:7 - Fault Protection Enable for channel 0 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe0 ( & self ) -> FPE0R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE0R { bits } } # [ doc = "Bits 8:15 - Fault Protection Enable for channel 1 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe1 ( & self ) -> FPE1R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE1R { bits } } # [ doc = "Bits 16:23 - Fault Protection Enable for channel 2 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe2 ( & self ) -> FPE2R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE2R { bits } } # [ doc = "Bits 24:31 - Fault Protection Enable for channel 3 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe3 ( & self ) -> FPE3R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE3R { 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 - Fault Protection Enable for channel 0 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe0 ( & mut self ) -> _FPE0W { _FPE0W { w : self } } # [ doc = "Bits 8:15 - Fault Protection Enable for channel 1 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe1 ( & mut self ) -> _FPE1W { _FPE1W { w : self } } # [ doc = "Bits 16:23 - Fault Protection Enable for channel 2 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe2 ( & mut self ) -> _FPE2W { _FPE2W { w : self } } # [ doc = "Bits 24:31 - Fault Protection Enable for channel 3 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe3 ( & mut self ) -> _FPE3W { _FPE3W { w : self } } } } # [ doc = "PWM Fault Protection Enable Register 2" ] pub struct FPE2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Fault Protection Enable Register 2" ] pub mod fpe2 { # [ 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 :: FPE2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FPE4R { bits : u8 , } impl FPE4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FPE5R { bits : u8 , } impl FPE5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FPE6R { bits : u8 , } impl FPE6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FPE7R { bits : u8 , } impl FPE7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _FPE4W < 'a > { w : & 'a mut W , } impl < 'a > _FPE4W < '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 _FPE5W < 'a > { w : & 'a mut W , } impl < 'a > _FPE5W < '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 _FPE6W < 'a > { w : & 'a mut W , } impl < 'a > _FPE6W < '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 _FPE7W < 'a > { w : & 'a mut W , } impl < 'a > _FPE7W < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:7 - Fault Protection Enable for channel 4 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe4 ( & self ) -> FPE4R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE4R { bits } } # [ doc = "Bits 8:15 - Fault Protection Enable for channel 5 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe5 ( & self ) -> FPE5R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE5R { bits } } # [ doc = "Bits 16:23 - Fault Protection Enable for channel 6 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe6 ( & self ) -> FPE6R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE6R { bits } } # [ doc = "Bits 24:31 - Fault Protection Enable for channel 7 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe7 ( & self ) -> FPE7R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPE7R { 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 - Fault Protection Enable for channel 4 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe4 ( & mut self ) -> _FPE4W { _FPE4W { w : self } } # [ doc = "Bits 8:15 - Fault Protection Enable for channel 5 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe5 ( & mut self ) -> _FPE5W { _FPE5W { w : self } } # [ doc = "Bits 16:23 - Fault Protection Enable for channel 6 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe6 ( & mut self ) -> _FPE6W { _FPE6W { w : self } } # [ doc = "Bits 24:31 - Fault Protection Enable for channel 7 (fault input bit varies from 0 to 5)" ] # [ inline ] pub fn fpe7 ( & mut self ) -> _FPE7W { _FPE7W { w : self } } } } # [ doc = "PWM Event Line 0 Mode Register" ] pub struct ELMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Event Line 0 Mode Register" ] pub mod elmr { # [ 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 :: ELMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 CSEL0R { bits : bool , } impl CSEL0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSEL1R { bits : bool , } impl CSEL1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSEL2R { bits : bool , } impl CSEL2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSEL3R { bits : bool , } impl CSEL3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSEL4R { bits : bool , } impl CSEL4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSEL5R { bits : bool , } impl CSEL5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSEL6R { bits : bool , } impl CSEL6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CSEL7R { bits : bool , } impl CSEL7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CSEL0W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSEL1W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSEL2W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSEL3W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSEL4W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSEL5W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSEL6W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CSEL7W < 'a > { w : & 'a mut W , } impl < 'a > _CSEL7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Comparison 0 Selection" ] # [ inline ] pub fn csel0 ( & self ) -> CSEL0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL0R { bits } } # [ doc = "Bit 1 - Comparison 1 Selection" ] # [ inline ] pub fn csel1 ( & self ) -> CSEL1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL1R { bits } } # [ doc = "Bit 2 - Comparison 2 Selection" ] # [ inline ] pub fn csel2 ( & self ) -> CSEL2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL2R { bits } } # [ doc = "Bit 3 - Comparison 3 Selection" ] # [ inline ] pub fn csel3 ( & self ) -> CSEL3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL3R { bits } } # [ doc = "Bit 4 - Comparison 4 Selection" ] # [ inline ] pub fn csel4 ( & self ) -> CSEL4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL4R { bits } } # [ doc = "Bit 5 - Comparison 5 Selection" ] # [ inline ] pub fn csel5 ( & self ) -> CSEL5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL5R { bits } } # [ doc = "Bit 6 - Comparison 6 Selection" ] # [ inline ] pub fn csel6 ( & self ) -> CSEL6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL6R { bits } } # [ doc = "Bit 7 - Comparison 7 Selection" ] # [ inline ] pub fn csel7 ( & self ) -> CSEL7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CSEL7R { bits } } } impl W { # [ doc = "Bit 0 - Comparison 0 Selection" ] # [ inline ] pub fn csel0 ( & mut self ) -> _CSEL0W { _CSEL0W { w : self } } # [ doc = "Bit 1 - Comparison 1 Selection" ] # [ inline ] pub fn csel1 ( & mut self ) -> _CSEL1W { _CSEL1W { w : self } } # [ doc = "Bit 2 - Comparison 2 Selection" ] # [ inline ] pub fn csel2 ( & mut self ) -> _CSEL2W { _CSEL2W { w : self } } # [ doc = "Bit 3 - Comparison 3 Selection" ] # [ inline ] pub fn csel3 ( & mut self ) -> _CSEL3W { _CSEL3W { w : self } } # [ doc = "Bit 4 - Comparison 4 Selection" ] # [ inline ] pub fn csel4 ( & mut self ) -> _CSEL4W { _CSEL4W { w : self } } # [ doc = "Bit 5 - Comparison 5 Selection" ] # [ inline ] pub fn csel5 ( & mut self ) -> _CSEL5W { _CSEL5W { w : self } } # [ doc = "Bit 6 - Comparison 6 Selection" ] # [ inline ] pub fn csel6 ( & mut self ) -> _CSEL6W { _CSEL6W { w : self } } # [ doc = "Bit 7 - Comparison 7 Selection" ] # [ inline ] pub fn csel7 ( & mut self ) -> _CSEL7W { _CSEL7W { w : self } } } } # [ doc = "PWM Stepper Motor Mode Register" ] pub struct SMMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Stepper Motor Mode Register" ] pub mod smmr { # [ 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 :: SMMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 GCEN0R { bits : bool , } impl GCEN0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GCEN1R { bits : bool , } impl GCEN1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GCEN2R { bits : bool , } impl GCEN2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GCEN3R { bits : bool , } impl GCEN3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DOWN0R { bits : bool , } impl DOWN0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DOWN1R { bits : bool , } impl DOWN1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DOWN2R { bits : bool , } impl DOWN2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DOWN3R { bits : bool , } impl DOWN3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _GCEN0W < 'a > { w : & 'a mut W , } impl < 'a > _GCEN0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GCEN1W < 'a > { w : & 'a mut W , } impl < 'a > _GCEN1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GCEN2W < 'a > { w : & 'a mut W , } impl < 'a > _GCEN2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GCEN3W < 'a > { w : & 'a mut W , } impl < 'a > _GCEN3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DOWN0W < 'a > { w : & 'a mut W , } impl < 'a > _DOWN0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DOWN1W < 'a > { w : & 'a mut W , } impl < 'a > _DOWN1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DOWN2W < 'a > { w : & 'a mut W , } impl < 'a > _DOWN2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DOWN3W < 'a > { w : & 'a mut W , } impl < 'a > _DOWN3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Gray Count ENable" ] # [ inline ] pub fn gcen0 ( & self ) -> GCEN0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCEN0R { bits } } # [ doc = "Bit 1 - Gray Count ENable" ] # [ inline ] pub fn gcen1 ( & self ) -> GCEN1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCEN1R { bits } } # [ doc = "Bit 2 - Gray Count ENable" ] # [ inline ] pub fn gcen2 ( & self ) -> GCEN2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCEN2R { bits } } # [ doc = "Bit 3 - Gray Count ENable" ] # [ inline ] pub fn gcen3 ( & self ) -> GCEN3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GCEN3R { bits } } # [ doc = "Bit 16 - DOWN Count" ] # [ inline ] pub fn down0 ( & self ) -> DOWN0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWN0R { bits } } # [ doc = "Bit 17 - DOWN Count" ] # [ inline ] pub fn down1 ( & self ) -> DOWN1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWN1R { bits } } # [ doc = "Bit 18 - DOWN Count" ] # [ inline ] pub fn down2 ( & self ) -> DOWN2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWN2R { bits } } # [ doc = "Bit 19 - DOWN Count" ] # [ inline ] pub fn down3 ( & self ) -> DOWN3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DOWN3R { 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 - Gray Count ENable" ] # [ inline ] pub fn gcen0 ( & mut self ) -> _GCEN0W { _GCEN0W { w : self } } # [ doc = "Bit 1 - Gray Count ENable" ] # [ inline ] pub fn gcen1 ( & mut self ) -> _GCEN1W { _GCEN1W { w : self } } # [ doc = "Bit 2 - Gray Count ENable" ] # [ inline ] pub fn gcen2 ( & mut self ) -> _GCEN2W { _GCEN2W { w : self } } # [ doc = "Bit 3 - Gray Count ENable" ] # [ inline ] pub fn gcen3 ( & mut self ) -> _GCEN3W { _GCEN3W { w : self } } # [ doc = "Bit 16 - DOWN Count" ] # [ inline ] pub fn down0 ( & mut self ) -> _DOWN0W { _DOWN0W { w : self } } # [ doc = "Bit 17 - DOWN Count" ] # [ inline ] pub fn down1 ( & mut self ) -> _DOWN1W { _DOWN1W { w : self } } # [ doc = "Bit 18 - DOWN Count" ] # [ inline ] pub fn down2 ( & mut self ) -> _DOWN2W { _DOWN2W { w : self } } # [ doc = "Bit 19 - DOWN Count" ] # [ inline ] pub fn down3 ( & mut self ) -> _DOWN3W { _DOWN3W { w : self } } } } # [ doc = "PWM Write Protect Control Register" ] pub struct WPCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Write Protect Control Register" ] pub mod wpcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: WPCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _WPCMDW < 'a > { w : & 'a mut W , } impl < 'a > _WPCMDW < '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 _WPRG0W < 'a > { w : & 'a mut W , } impl < 'a > _WPRG0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPRG1W < 'a > { w : & 'a mut W , } impl < 'a > _WPRG1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPRG2W < 'a > { w : & 'a mut W , } impl < 'a > _WPRG2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPRG3W < 'a > { w : & 'a mut W , } impl < 'a > _WPRG3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPRG4W < 'a > { w : & 'a mut W , } impl < 'a > _WPRG4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPRG5W < 'a > { w : & 'a mut W , } impl < 'a > _WPRG5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bits 0:1 - Write Protect Command" ] # [ inline ] pub fn wpcmd ( & mut self ) -> _WPCMDW { _WPCMDW { w : self } } # [ doc = "Bit 2 - Write Protect Register Group 0" ] # [ inline ] pub fn wprg0 ( & mut self ) -> _WPRG0W { _WPRG0W { w : self } } # [ doc = "Bit 3 - Write Protect Register Group 1" ] # [ inline ] pub fn wprg1 ( & mut self ) -> _WPRG1W { _WPRG1W { w : self } } # [ doc = "Bit 4 - Write Protect Register Group 2" ] # [ inline ] pub fn wprg2 ( & mut self ) -> _WPRG2W { _WPRG2W { w : self } } # [ doc = "Bit 5 - Write Protect Register Group 3" ] # [ inline ] pub fn wprg3 ( & mut self ) -> _WPRG3W { _WPRG3W { w : self } } # [ doc = "Bit 6 - Write Protect Register Group 4" ] # [ inline ] pub fn wprg4 ( & mut self ) -> _WPRG4W { _WPRG4W { w : self } } # [ doc = "Bit 7 - Write Protect Register Group 5" ] # [ inline ] pub fn wprg5 ( & mut self ) -> _WPRG5W { _WPRG5W { w : self } } # [ doc = "Bits 8:31 - Write Protect Key" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "PWM Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPSWS0R { bits : bool , } impl WPSWS0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPSWS1R { bits : bool , } impl WPSWS1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPSWS2R { bits : bool , } impl WPSWS2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPSWS3R { bits : bool , } impl WPSWS3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPSWS4R { bits : bool , } impl WPSWS4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPSWS5R { bits : bool , } impl WPSWS5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPHWS0R { bits : bool , } impl WPHWS0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPHWS1R { bits : bool , } impl WPHWS1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPHWS2R { bits : bool , } impl WPHWS2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPHWS3R { bits : bool , } impl WPHWS3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPHWS4R { bits : bool , } impl WPHWS4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPHWS5R { bits : bool , } impl WPHWS5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect SW Status" ] # [ inline ] pub fn wpsws0 ( & self ) -> WPSWS0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPSWS0R { bits } } # [ doc = "Bit 1 - Write Protect SW Status" ] # [ inline ] pub fn wpsws1 ( & self ) -> WPSWS1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPSWS1R { bits } } # [ doc = "Bit 2 - Write Protect SW Status" ] # [ inline ] pub fn wpsws2 ( & self ) -> WPSWS2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPSWS2R { bits } } # [ doc = "Bit 3 - Write Protect SW Status" ] # [ inline ] pub fn wpsws3 ( & self ) -> WPSWS3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPSWS3R { bits } } # [ doc = "Bit 4 - Write Protect SW Status" ] # [ inline ] pub fn wpsws4 ( & self ) -> WPSWS4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPSWS4R { bits } } # [ doc = "Bit 5 - Write Protect SW Status" ] # [ inline ] pub fn wpsws5 ( & self ) -> WPSWS5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPSWS5R { bits } } # [ doc = "Bit 7 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bit 8 - Write Protect HW Status" ] # [ inline ] pub fn wphws0 ( & self ) -> WPHWS0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPHWS0R { bits } } # [ doc = "Bit 9 - Write Protect HW Status" ] # [ inline ] pub fn wphws1 ( & self ) -> WPHWS1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPHWS1R { bits } } # [ doc = "Bit 10 - Write Protect HW Status" ] # [ inline ] pub fn wphws2 ( & self ) -> WPHWS2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPHWS2R { bits } } # [ doc = "Bit 11 - Write Protect HW Status" ] # [ inline ] pub fn wphws3 ( & self ) -> WPHWS3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPHWS3R { bits } } # [ doc = "Bit 12 - Write Protect HW Status" ] # [ inline ] pub fn wphws4 ( & self ) -> WPHWS4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPHWS4R { bits } } # [ doc = "Bit 13 - Write Protect HW Status" ] # [ inline ] pub fn wphws5 ( & self ) -> WPHWS5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPHWS5R { bits } } # [ doc = "Bits 16:31 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "PWM Comparison 0 Value Register" ] pub struct CMPV0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 0 Value Register" ] pub mod cmpv0 { # [ 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 :: CMPV0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 0 Value Update Register" ] pub struct CMPVUPD0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 0 Value Update Register" ] pub mod cmpvupd0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 0 Mode Register" ] pub struct CMPM0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 0 Mode Register" ] pub mod cmpm0 { # [ 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 :: CMPM0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 0 Mode Update Register" ] pub struct CMPMUPD0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 0 Mode Update Register" ] pub mod cmpmupd0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Comparison 1 Value Register" ] pub struct CMPV1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 1 Value Register" ] pub mod cmpv1 { # [ 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 :: CMPV1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 1 Value Update Register" ] pub struct CMPVUPD1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 1 Value Update Register" ] pub mod cmpvupd1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 1 Mode Register" ] pub struct CMPM1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 1 Mode Register" ] pub mod cmpm1 { # [ 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 :: CMPM1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 1 Mode Update Register" ] pub struct CMPMUPD1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 1 Mode Update Register" ] pub mod cmpmupd1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Comparison 2 Value Register" ] pub struct CMPV2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 2 Value Register" ] pub mod cmpv2 { # [ 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 :: CMPV2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 2 Value Update Register" ] pub struct CMPVUPD2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 2 Value Update Register" ] pub mod cmpvupd2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 2 Mode Register" ] pub struct CMPM2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 2 Mode Register" ] pub mod cmpm2 { # [ 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 :: CMPM2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 2 Mode Update Register" ] pub struct CMPMUPD2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 2 Mode Update Register" ] pub mod cmpmupd2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Comparison 3 Value Register" ] pub struct CMPV3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 3 Value Register" ] pub mod cmpv3 { # [ 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 :: CMPV3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 3 Value Update Register" ] pub struct CMPVUPD3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 3 Value Update Register" ] pub mod cmpvupd3 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD3 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 3 Mode Register" ] pub struct CMPM3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 3 Mode Register" ] pub mod cmpm3 { # [ 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 :: CMPM3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 3 Mode Update Register" ] pub struct CMPMUPD3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 3 Mode Update Register" ] pub mod cmpmupd3 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD3 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Comparison 4 Value Register" ] pub struct CMPV4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 4 Value Register" ] pub mod cmpv4 { # [ 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 :: CMPV4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 4 Value Update Register" ] pub struct CMPVUPD4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 4 Value Update Register" ] pub mod cmpvupd4 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD4 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 4 Mode Register" ] pub struct CMPM4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 4 Mode Register" ] pub mod cmpm4 { # [ 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 :: CMPM4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 4 Mode Update Register" ] pub struct CMPMUPD4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 4 Mode Update Register" ] pub mod cmpmupd4 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD4 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Comparison 5 Value Register" ] pub struct CMPV5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 5 Value Register" ] pub mod cmpv5 { # [ 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 :: CMPV5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 5 Value Update Register" ] pub struct CMPVUPD5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 5 Value Update Register" ] pub mod cmpvupd5 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD5 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 5 Mode Register" ] pub struct CMPM5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 5 Mode Register" ] pub mod cmpm5 { # [ 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 :: CMPM5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 5 Mode Update Register" ] pub struct CMPMUPD5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 5 Mode Update Register" ] pub mod cmpmupd5 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD5 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Comparison 6 Value Register" ] pub struct CMPV6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 6 Value Register" ] pub mod cmpv6 { # [ 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 :: CMPV6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 6 Value Update Register" ] pub struct CMPVUPD6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 6 Value Update Register" ] pub mod cmpvupd6 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD6 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 6 Mode Register" ] pub struct CMPM6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 6 Mode Register" ] pub mod cmpm6 { # [ 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 :: CMPM6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 6 Mode Update Register" ] pub struct CMPMUPD6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 6 Mode Update Register" ] pub mod cmpmupd6 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD6 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Comparison 7 Value Register" ] pub struct CMPV7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 7 Value Register" ] pub mod cmpv7 { # [ 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 :: CMPV7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CVR { bits : u32 , } impl CVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct CVMR { bits : bool , } impl CVMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _CVW < 'a > { w : & 'a mut W , } impl < 'a > _CVW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMW < 'a > { w : & 'a mut W , } impl < 'a > _CVMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & self ) -> CVR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CVR { bits } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & self ) -> CVMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CVMR { 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:23 - Comparison x Value" ] # [ inline ] pub fn cv ( & mut self ) -> _CVW { _CVW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode" ] # [ inline ] pub fn cvm ( & mut self ) -> _CVMW { _CVMW { w : self } } } } # [ doc = "PWM Comparison 7 Value Update Register" ] pub struct CMPVUPD7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 7 Value Update Register" ] pub mod cmpvupd7 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPVUPD7 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CVUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _CVMUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CVMUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 0:23 - Comparison x Value Update" ] # [ inline ] pub fn cvupd ( & mut self ) -> _CVUPDW { _CVUPDW { w : self } } # [ doc = "Bit 24 - Comparison x Value Mode Update" ] # [ inline ] pub fn cvmupd ( & mut self ) -> _CVMUPDW { _CVMUPDW { w : self } } } } # [ doc = "PWM Comparison 7 Mode Register" ] pub struct CMPM7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 7 Mode Register" ] pub mod cmpm7 { # [ 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 :: CMPM7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 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" Value of the field" ] pub struct CTRR { bits : u8 , } impl CTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRR { bits : u8 , } impl CPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CPRCNTR { bits : u8 , } impl CPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRR { bits : u8 , } impl CUPRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CUPRCNTR { bits : u8 , } impl CUPRCNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CTRW < 'a > { w : & 'a mut W , } impl < 'a > _CTRW < '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 _CPRW < 'a > { w : & 'a mut W , } impl < 'a > _CPRW < '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 _CPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CPRCNTW < '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 _CUPRW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRW < '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 _CUPRCNTW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRCNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Comparison x 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 } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & self ) -> CTRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CTRR { bits } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & self ) -> CPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRR { bits } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & self ) -> CPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CPRCNTR { bits } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & self ) -> CUPRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRR { bits } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & self ) -> CUPRCNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CUPRCNTR { 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 - Comparison x Enable" ] # [ inline ] pub fn cen ( & mut self ) -> _CENW { _CENW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger" ] # [ inline ] pub fn ctr ( & mut self ) -> _CTRW { _CTRW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period" ] # [ inline ] pub fn cpr ( & mut self ) -> _CPRW { _CPRW { w : self } } # [ doc = "Bits 12:15 - Comparison x Period Counter" ] # [ inline ] pub fn cprcnt ( & mut self ) -> _CPRCNTW { _CPRCNTW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period" ] # [ inline ] pub fn cupr ( & mut self ) -> _CUPRW { _CUPRW { w : self } } # [ doc = "Bits 20:23 - Comparison x Update Period Counter" ] # [ inline ] pub fn cuprcnt ( & mut self ) -> _CUPRCNTW { _CUPRCNTW { w : self } } } } # [ doc = "PWM Comparison 7 Mode Update Register" ] pub struct CMPMUPD7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Comparison 7 Mode Update Register" ] pub mod cmpmupd7 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CMPMUPD7 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CENUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CENUPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CTRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CTRUPDW < '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 _CPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRUPDW < '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 _CUPRUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CUPRUPDW < '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 } } impl W { # [ doc = "Bit 0 - Comparison x Enable Update" ] # [ inline ] pub fn cenupd ( & mut self ) -> _CENUPDW { _CENUPDW { w : self } } # [ doc = "Bits 4:7 - Comparison x Trigger Update" ] # [ inline ] pub fn ctrupd ( & mut self ) -> _CTRUPDW { _CTRUPDW { w : self } } # [ doc = "Bits 8:11 - Comparison x Period Update" ] # [ inline ] pub fn cprupd ( & mut self ) -> _CPRUPDW { _CPRUPDW { w : self } } # [ doc = "Bits 16:19 - Comparison x Update Period Update" ] # [ inline ] pub fn cuprupd ( & mut self ) -> _CUPRUPDW { _CUPRUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 0)" ] pub struct CMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 0)" ] pub mod cmr0 { # [ 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 :: CMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 0)" ] pub struct CDTY0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 0)" ] pub mod cdty0 { # [ 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 :: CDTY0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 0)" ] pub struct CDTYUPD0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 0)" ] pub mod cdtyupd0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 0)" ] pub struct CPRD0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 0)" ] pub mod cprd0 { # [ 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 :: CPRD0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 0)" ] pub struct CPRDUPD0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 0)" ] pub mod cprdupd0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 0)" ] pub struct CCNT0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 0)" ] pub mod ccnt0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT0 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 0)" ] pub struct DT0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 0)" ] pub mod dt0 { # [ 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 :: DT0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 0)" ] pub struct DTUPD0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 0)" ] pub mod dtupd0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 1)" ] pub struct CMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 1)" ] pub mod cmr1 { # [ 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 :: CMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 1)" ] pub struct CDTY1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 1)" ] pub mod cdty1 { # [ 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 :: CDTY1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 1)" ] pub struct CDTYUPD1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 1)" ] pub mod cdtyupd1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 1)" ] pub struct CPRD1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 1)" ] pub mod cprd1 { # [ 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 :: CPRD1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 1)" ] pub struct CPRDUPD1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 1)" ] pub mod cprdupd1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 1)" ] pub struct CCNT1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 1)" ] pub mod ccnt1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT1 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 1)" ] pub struct DT1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 1)" ] pub mod dt1 { # [ 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 :: DT1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 1)" ] pub struct DTUPD1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 1)" ] pub mod dtupd1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 2)" ] pub struct CMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 2)" ] pub mod cmr2 { # [ 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 :: CMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 2)" ] pub struct CDTY2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 2)" ] pub mod cdty2 { # [ 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 :: CDTY2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 2)" ] pub struct CDTYUPD2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 2)" ] pub mod cdtyupd2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 2)" ] pub struct CPRD2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 2)" ] pub mod cprd2 { # [ 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 :: CPRD2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 2)" ] pub struct CPRDUPD2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 2)" ] pub mod cprdupd2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 2)" ] pub struct CCNT2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 2)" ] pub mod ccnt2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT2 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 2)" ] pub struct DT2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 2)" ] pub mod dt2 { # [ 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 :: DT2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 2)" ] pub struct DTUPD2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 2)" ] pub mod dtupd2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 3)" ] pub struct CMR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 3)" ] pub mod cmr3 { # [ 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 :: CMR3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 3)" ] pub struct CDTY3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 3)" ] pub mod cdty3 { # [ 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 :: CDTY3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 3)" ] pub struct CDTYUPD3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 3)" ] pub mod cdtyupd3 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD3 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 3)" ] pub struct CPRD3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 3)" ] pub mod cprd3 { # [ 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 :: CPRD3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 3)" ] pub struct CPRDUPD3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 3)" ] pub mod cprdupd3 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD3 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 3)" ] pub struct CCNT3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 3)" ] pub mod ccnt3 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT3 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 3)" ] pub struct DT3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 3)" ] pub mod dt3 { # [ 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 :: DT3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 3)" ] pub struct DTUPD3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 3)" ] pub mod dtupd3 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD3 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 4)" ] pub struct CMR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 4)" ] pub mod cmr4 { # [ 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 :: CMR4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 4)" ] pub struct CDTY4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 4)" ] pub mod cdty4 { # [ 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 :: CDTY4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 4)" ] pub struct CDTYUPD4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 4)" ] pub mod cdtyupd4 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD4 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 4)" ] pub struct CPRD4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 4)" ] pub mod cprd4 { # [ 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 :: CPRD4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 4)" ] pub struct CPRDUPD4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 4)" ] pub mod cprdupd4 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD4 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 4)" ] pub struct CCNT4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 4)" ] pub mod ccnt4 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT4 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 4)" ] pub struct DT4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 4)" ] pub mod dt4 { # [ 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 :: DT4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 4)" ] pub struct DTUPD4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 4)" ] pub mod dtupd4 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD4 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 5)" ] pub struct CMR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 5)" ] pub mod cmr5 { # [ 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 :: CMR5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 5)" ] pub struct CDTY5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 5)" ] pub mod cdty5 { # [ 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 :: CDTY5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 5)" ] pub struct CDTYUPD5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 5)" ] pub mod cdtyupd5 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD5 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 5)" ] pub struct CPRD5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 5)" ] pub mod cprd5 { # [ 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 :: CPRD5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 5)" ] pub struct CPRDUPD5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 5)" ] pub mod cprdupd5 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD5 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 5)" ] pub struct CCNT5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 5)" ] pub mod ccnt5 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT5 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 5)" ] pub struct DT5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 5)" ] pub mod dt5 { # [ 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 :: DT5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 5)" ] pub struct DTUPD5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 5)" ] pub mod dtupd5 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD5 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 6)" ] pub struct CMR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 6)" ] pub mod cmr6 { # [ 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 :: CMR6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 6)" ] pub struct CDTY6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 6)" ] pub mod cdty6 { # [ 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 :: CDTY6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 6)" ] pub struct CDTYUPD6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 6)" ] pub mod cdtyupd6 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD6 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 6)" ] pub struct CPRD6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 6)" ] pub mod cprd6 { # [ 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 :: CPRD6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 6)" ] pub struct CPRDUPD6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 6)" ] pub mod cprdupd6 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD6 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 6)" ] pub struct CCNT6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 6)" ] pub mod ccnt6 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT6 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 6)" ] pub struct DT6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 6)" ] pub mod dt6 { # [ 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 :: DT6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 6)" ] pub struct DTUPD6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 6)" ] pub mod dtupd6 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD6 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "PWM Channel Mode Register (ch_num = 7)" ] pub struct CMR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Mode Register (ch_num = 7)" ] pub mod cmr7 { # [ 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 :: CMR7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CPRE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CPRER { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CPRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CPRER :: MCK => 0 , CPRER :: MCK_DIV_2 => 0x01 , CPRER :: MCK_DIV_4 => 0x02 , CPRER :: MCK_DIV_8 => 0x03 , CPRER :: MCK_DIV_16 => 0x04 , CPRER :: MCK_DIV_32 => 0x05 , CPRER :: MCK_DIV_64 => 0x06 , CPRER :: MCK_DIV_128 => 0x07 , CPRER :: MCK_DIV_256 => 0x08 , CPRER :: MCK_DIV_512 => 0x09 , CPRER :: MCK_DIV_1024 => 0x0a , CPRER :: CLKA => 0x0b , CPRER :: CLKB => 0x0c , CPRER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CPRER { match value { 0 => CPRER :: MCK , 1 => CPRER :: MCK_DIV_2 , 2 => CPRER :: MCK_DIV_4 , 3 => CPRER :: MCK_DIV_8 , 4 => CPRER :: MCK_DIV_16 , 5 => CPRER :: MCK_DIV_32 , 6 => CPRER :: MCK_DIV_64 , 7 => CPRER :: MCK_DIV_128 , 8 => CPRER :: MCK_DIV_256 , 9 => CPRER :: MCK_DIV_512 , 10 => CPRER :: MCK_DIV_1024 , 11 => CPRER :: CLKA , 12 => CPRER :: CLKB , i => CPRER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CPRER :: MCK } # [ doc = "Checks if the value of the field is `MCK_DIV_2`" ] # [ inline ] pub fn is_mck_div_2 ( & self ) -> bool { * self == CPRER :: MCK_DIV_2 } # [ doc = "Checks if the value of the field is `MCK_DIV_4`" ] # [ inline ] pub fn is_mck_div_4 ( & self ) -> bool { * self == CPRER :: MCK_DIV_4 } # [ doc = "Checks if the value of the field is `MCK_DIV_8`" ] # [ inline ] pub fn is_mck_div_8 ( & self ) -> bool { * self == CPRER :: MCK_DIV_8 } # [ doc = "Checks if the value of the field is `MCK_DIV_16`" ] # [ inline ] pub fn is_mck_div_16 ( & self ) -> bool { * self == CPRER :: MCK_DIV_16 } # [ doc = "Checks if the value of the field is `MCK_DIV_32`" ] # [ inline ] pub fn is_mck_div_32 ( & self ) -> bool { * self == CPRER :: MCK_DIV_32 } # [ doc = "Checks if the value of the field is `MCK_DIV_64`" ] # [ inline ] pub fn is_mck_div_64 ( & self ) -> bool { * self == CPRER :: MCK_DIV_64 } # [ doc = "Checks if the value of the field is `MCK_DIV_128`" ] # [ inline ] pub fn is_mck_div_128 ( & self ) -> bool { * self == CPRER :: MCK_DIV_128 } # [ doc = "Checks if the value of the field is `MCK_DIV_256`" ] # [ inline ] pub fn is_mck_div_256 ( & self ) -> bool { * self == CPRER :: MCK_DIV_256 } # [ doc = "Checks if the value of the field is `MCK_DIV_512`" ] # [ inline ] pub fn is_mck_div_512 ( & self ) -> bool { * self == CPRER :: MCK_DIV_512 } # [ doc = "Checks if the value of the field is `MCK_DIV_1024`" ] # [ inline ] pub fn is_mck_div_1024 ( & self ) -> bool { * self == CPRER :: MCK_DIV_1024 } # [ doc = "Checks if the value of the field is `CLKA`" ] # [ inline ] pub fn is_clka ( & self ) -> bool { * self == CPRER :: CLKA } # [ doc = "Checks if the value of the field is `CLKB`" ] # [ inline ] pub fn is_clkb ( & self ) -> bool { * self == CPRER :: CLKB } } # [ doc = r" Value of the field" ] pub struct CALGR { bits : bool , } impl CALGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CESR { bits : bool , } impl CESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTER { bits : bool , } impl DTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTHIR { bits : bool , } impl DTHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTLIR { bits : bool , } impl DTLIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CPRE`" ] pub enum CPREW { # [ doc = "Master clock" ] MCK , # [ doc = "Master clock/2" ] MCK_DIV_2 , # [ doc = "Master clock/4" ] MCK_DIV_4 , # [ doc = "Master clock/8" ] MCK_DIV_8 , # [ doc = "Master clock/16" ] MCK_DIV_16 , # [ doc = "Master clock/32" ] MCK_DIV_32 , # [ doc = "Master clock/64" ] MCK_DIV_64 , # [ doc = "Master clock/128" ] MCK_DIV_128 , # [ doc = "Master clock/256" ] MCK_DIV_256 , # [ doc = "Master clock/512" ] MCK_DIV_512 , # [ doc = "Master clock/1024" ] MCK_DIV_1024 , # [ doc = "Clock A" ] CLKA , # [ doc = "Clock B" ] CLKB } impl CPREW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CPREW :: MCK => 0 , CPREW :: MCK_DIV_2 => 1 , CPREW :: MCK_DIV_4 => 2 , CPREW :: MCK_DIV_8 => 3 , CPREW :: MCK_DIV_16 => 4 , CPREW :: MCK_DIV_32 => 5 , CPREW :: MCK_DIV_64 => 6 , CPREW :: MCK_DIV_128 => 7 , CPREW :: MCK_DIV_256 => 8 , CPREW :: MCK_DIV_512 => 9 , CPREW :: MCK_DIV_1024 => 10 , CPREW :: CLKA => 11 , CPREW :: CLKB => 12 } } } # [ doc = r" Proxy" ] pub struct _CPREW < 'a > { w : & 'a mut W , } impl < 'a > _CPREW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CPREW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Master clock" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK ) } # [ doc = "Master clock/2" ] # [ inline ] pub fn mck_div_2 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_2 ) } # [ doc = "Master clock/4" ] # [ inline ] pub fn mck_div_4 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_4 ) } # [ doc = "Master clock/8" ] # [ inline ] pub fn mck_div_8 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_8 ) } # [ doc = "Master clock/16" ] # [ inline ] pub fn mck_div_16 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_16 ) } # [ doc = "Master clock/32" ] # [ inline ] pub fn mck_div_32 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_32 ) } # [ doc = "Master clock/64" ] # [ inline ] pub fn mck_div_64 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_64 ) } # [ doc = "Master clock/128" ] # [ inline ] pub fn mck_div_128 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_128 ) } # [ doc = "Master clock/256" ] # [ inline ] pub fn mck_div_256 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_256 ) } # [ doc = "Master clock/512" ] # [ inline ] pub fn mck_div_512 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_512 ) } # [ doc = "Master clock/1024" ] # [ inline ] pub fn mck_div_1024 ( self ) -> & 'a mut W { self . variant ( CPREW :: MCK_DIV_1024 ) } # [ doc = "Clock A" ] # [ inline ] pub fn clka ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKA ) } # [ doc = "Clock B" ] # [ inline ] pub fn clkb ( self ) -> & 'a mut W { self . variant ( CPREW :: CLKB ) } # [ 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 } } # [ doc = r" Proxy" ] pub struct _CALGW < 'a > { w : & 'a mut W , } impl < 'a > _CALGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CESW < 'a > { w : & 'a mut W , } impl < 'a > _CESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTEW < 'a > { w : & 'a mut W , } impl < 'a > _DTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTHIW < 'a > { w : & 'a mut W , } impl < 'a > _DTHIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTLIW < 'a > { w : & 'a mut W , } impl < 'a > _DTLIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:3 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & self ) -> CPRER { CPRER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & self ) -> CALGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALGR { bits } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & self ) -> CESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CESR { bits } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & self ) -> DTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTER { bits } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & self ) -> DTHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTHIR { bits } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & self ) -> DTLIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTLIR { 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 - Channel Pre-scaler" ] # [ inline ] pub fn cpre ( & mut self ) -> _CPREW { _CPREW { w : self } } # [ doc = "Bit 8 - Channel Alignment" ] # [ inline ] pub fn calg ( & mut self ) -> _CALGW { _CALGW { w : self } } # [ doc = "Bit 9 - Channel Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 10 - Counter Event Selection" ] # [ inline ] pub fn ces ( & mut self ) -> _CESW { _CESW { w : self } } # [ doc = "Bit 16 - Dead-Time Generator Enable" ] # [ inline ] pub fn dte ( & mut self ) -> _DTEW { _DTEW { w : self } } # [ doc = "Bit 17 - Dead-Time PWMHx Output Inverted" ] # [ inline ] pub fn dthi ( & mut self ) -> _DTHIW { _DTHIW { w : self } } # [ doc = "Bit 18 - Dead-Time PWMLx Output Inverted" ] # [ inline ] pub fn dtli ( & mut self ) -> _DTLIW { _DTLIW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 7)" ] pub struct CDTY7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Register (ch_num = 7)" ] pub mod cdty7 { # [ 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 :: CDTY7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDTYR { bits : u32 , } impl CDTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDTYW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYW < '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 0:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & self ) -> CDTYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CDTYR { 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:23 - Channel Duty-Cycle" ] # [ inline ] pub fn cdty ( & mut self ) -> _CDTYW { _CDTYW { w : self } } } } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 7)" ] pub struct CDTYUPD7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Duty Cycle Update Register (ch_num = 7)" ] pub mod cdtyupd7 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDTYUPD7 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CDTYUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CDTYUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Duty-Cycle Update" ] # [ inline ] pub fn cdtyupd ( & mut self ) -> _CDTYUPDW { _CDTYUPDW { w : self } } } } # [ doc = "PWM Channel Period Register (ch_num = 7)" ] pub struct CPRD7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Register (ch_num = 7)" ] pub mod cprd7 { # [ 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 :: CPRD7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CPRDR { bits : u32 , } impl CPRDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _CPRDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDW < '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 0:23 - Channel Period" ] # [ inline ] pub fn cprd ( & self ) -> CPRDR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CPRDR { 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:23 - Channel Period" ] # [ inline ] pub fn cprd ( & mut self ) -> _CPRDW { _CPRDW { w : self } } } } # [ doc = "PWM Channel Period Update Register (ch_num = 7)" ] pub struct CPRDUPD7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Period Update Register (ch_num = 7)" ] pub mod cprdupd7 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CPRDUPD7 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CPRDUPDW < 'a > { w : & 'a mut W , } impl < 'a > _CPRDUPDW < '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 W { # [ doc = "Bits 0:23 - Channel Period Update" ] # [ inline ] pub fn cprdupd ( & mut self ) -> _CPRDUPDW { _CPRDUPDW { w : self } } } } # [ doc = "PWM Channel Counter Register (ch_num = 7)" ] pub struct CCNT7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Counter Register (ch_num = 7)" ] pub mod ccnt7 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CCNT7 { # [ 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 CNTR { bits : u32 , } impl CNTR { # [ 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:23 - Channel Counter Register" ] # [ inline ] pub fn cnt ( & self ) -> CNTR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CNTR { bits } } } } # [ doc = "PWM Channel Dead Time Register (ch_num = 7)" ] pub struct DT7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Register (ch_num = 7)" ] pub mod dt7 { # [ 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 :: DT7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTHR { bits : u16 , } impl DTHR { # [ 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 DTLR { bits : u16 , } impl DTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTHW < 'a > { w : & 'a mut W , } impl < 'a > _DTHW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLW < 'a > { w : & 'a mut W , } impl < 'a > _DTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & self ) -> DTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTHR { bits } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & self ) -> DTLR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTLR { 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 - Dead-Time Value for PWMHx Output" ] # [ inline ] pub fn dth ( & mut self ) -> _DTHW { _DTHW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value for PWMLx Output" ] # [ inline ] pub fn dtl ( & mut self ) -> _DTLW { _DTLW { w : self } } } } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 7)" ] pub struct DTUPD7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PWM Channel Dead Time Update Register (ch_num = 7)" ] pub mod dtupd7 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DTUPD7 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DTHUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTHUPDW < '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 } } # [ doc = r" Proxy" ] pub struct _DTLUPDW < 'a > { w : & 'a mut W , } impl < 'a > _DTLUPDW < '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 } } impl W { # [ doc = "Bits 0:15 - Dead-Time Value Update for PWMHx Output" ] # [ inline ] pub fn dthupd ( & mut self ) -> _DTHUPDW { _DTHUPDW { w : self } } # [ doc = "Bits 16:31 - Dead-Time Value Update for PWMLx Output" ] # [ inline ] pub fn dtlupd ( & mut self ) -> _DTLUPDW { _DTLUPDW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 0" ] pub struct USART0 { _marker : PhantomData < * const ( ) > } unsafe impl Send for USART0 { } impl USART0 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const usart0 :: RegisterBlock { 0x4009_8000 as * const _ } } impl Deref for USART0 { type Target = usart0 :: RegisterBlock ; fn deref ( & self ) -> & usart0 :: RegisterBlock { unsafe { & * USART0 :: ptr ( ) } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 0" ] pub mod usart0 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "Control Register" ] pub cr : CR_UNION , # [ doc = "Mode Register" ] pub mr : MR_UNION , # [ doc = "Interrupt Enable Register" ] pub ier : IER_UNION , # [ doc = "Interrupt Disable Register" ] pub idr : IDR_UNION , # [ doc = "Interrupt Mask Register" ] pub imr : IMR_UNION , # [ doc = "Channel Status Register" ] pub csr : CSR_UNION , # [ doc = "0x18 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x1c - Transmit Holding Register" ] pub thr : THR , # [ doc = "0x20 - Baud Rate Generator Register" ] pub brgr : BRGR , # [ doc = "0x24 - Receiver Time-out Register" ] pub rtor : RTOR , # [ doc = "0x28 - Transmitter Timeguard Register" ] pub ttgr : TTGR , _reserved11 : [ u8 ; 20usize ] , # [ doc = "0x40 - FI DI Ratio Register" ] pub fidi : FIDI , # [ doc = "0x44 - Number of Errors Register" ] pub ner : NER , _reserved13 : [ u8 ; 4usize ] , # [ doc = "0x4c - IrDA Filter Register" ] pub if_ : IF , # [ doc = "0x50 - Manchester Configuration Register" ] pub man : MAN , # [ doc = "0x54 - LIN Mode Register" ] pub linmr : LINMR , # [ doc = "0x58 - LIN Identifier Register" ] pub linir : LINIR , # [ doc = "0x5c - LIN Baud Rate Register" ] pub linbrr : LINBRR , _reserved18 : [ u8 ; 132usize ] , # [ doc = "0xe4 - Write Protection Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protection Status Register" ] pub wpsr : WPSR , _reserved20 : [ u8 ; 20usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] # [ repr ( C ) ] pub union CR_UNION { # [ doc = "0x00 - Control Register" ] pub cr_spi_mode : CR_SPI_MODE , # [ doc = "0x00 - Control Register" ] pub cr : CR , } # [ doc = "Mode Register" ] # [ repr ( C ) ] pub union MR_UNION { # [ doc = "0x04 - Mode Register" ] pub mr_spi_mode : MR_SPI_MODE , # [ doc = "0x04 - Mode Register" ] pub mr : MR , } # [ doc = "Interrupt Enable Register" ] # [ repr ( C ) ] pub union IER_UNION { # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_lin_mode : IER_LIN_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_spi_mode : IER_SPI_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier : IER , } # [ doc = "Interrupt Disable Register" ] # [ repr ( C ) ] pub union IDR_UNION { # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_lin_mode : IDR_LIN_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_spi_mode : IDR_SPI_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr : IDR , } # [ doc = "Interrupt Mask Register" ] # [ repr ( C ) ] pub union IMR_UNION { # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_lin_mode : IMR_LIN_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_spi_mode : IMR_SPI_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr : IMR , } # [ doc = "Channel Status Register" ] # [ repr ( C ) ] pub union CSR_UNION { # [ doc = "0x14 - Channel Status Register" ] pub csr_lin_mode : CSR_LIN_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr_spi_mode : CSR_SPI_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr : CSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STTBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STPBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STPBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTTOW < 'a > { w : & 'a mut W , } impl < 'a > _STTTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SENDAW < 'a > { w : & 'a mut W , } impl < 'a > _SENDAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTITW < 'a > { w : & 'a mut W , } impl < 'a > _RSTITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTNACKW < 'a > { w : & 'a mut W , } impl < 'a > _RSTNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RETTOW < 'a > { w : & 'a mut W , } impl < 'a > _RETTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSENW < 'a > { w : & 'a mut W , } impl < 'a > _RTSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSDISW < 'a > { w : & 'a mut W , } impl < 'a > _RTSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINABTW < 'a > { w : & 'a mut W , } impl < 'a > _LINABTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINWKUPW < 'a > { w : & 'a mut W , } impl < 'a > _LINWKUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 9 - Start Break" ] # [ inline ] pub fn sttbrk ( & mut self ) -> _STTBRKW { _STTBRKW { w : self } } # [ doc = "Bit 10 - Stop Break" ] # [ inline ] pub fn stpbrk ( & mut self ) -> _STPBRKW { _STPBRKW { w : self } } # [ doc = "Bit 11 - Start Time-out" ] # [ inline ] pub fn sttto ( & mut self ) -> _STTTOW { _STTTOW { w : self } } # [ doc = "Bit 12 - Send Address" ] # [ inline ] pub fn senda ( & mut self ) -> _SENDAW { _SENDAW { w : self } } # [ doc = "Bit 13 - Reset Iterations" ] # [ inline ] pub fn rstit ( & mut self ) -> _RSTITW { _RSTITW { w : self } } # [ doc = "Bit 14 - Reset Non Acknowledge" ] # [ inline ] pub fn rstnack ( & mut self ) -> _RSTNACKW { _RSTNACKW { w : self } } # [ doc = "Bit 15 - Rearm Time-out" ] # [ inline ] pub fn retto ( & mut self ) -> _RETTOW { _RETTOW { w : self } } # [ doc = "Bit 18 - Request to Send Enable" ] # [ inline ] pub fn rtsen ( & mut self ) -> _RTSENW { _RTSENW { w : self } } # [ doc = "Bit 19 - Request to Send Disable" ] # [ inline ] pub fn rtsdis ( & mut self ) -> _RTSDISW { _RTSDISW { w : self } } # [ doc = "Bit 20 - Abort LIN Transmission" ] # [ inline ] pub fn linabt ( & mut self ) -> _LINABTW { _LINABTW { w : self } } # [ doc = "Bit 21 - Send LIN Wakeup Signal" ] # [ inline ] pub fn linwkup ( & mut self ) -> _LINWKUPW { _LINWKUPW { w : self } } } } # [ doc = "Control Register" ] pub struct CR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCSW < 'a > { w : & 'a mut W , } impl < 'a > _FCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCSW < 'a > { w : & 'a mut W , } impl < 'a > _RCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 18 - Force SPI Chip Select" ] # [ inline ] pub fn fcs ( & mut self ) -> _FCSW { _FCSW { w : self } } # [ doc = "Bit 19 - Release SPI Chip Select" ] # [ inline ] pub fn rcs ( & mut self ) -> _RCSW { _RCSW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: NORMAL => 0 , USART_MODER :: RS485 => 0x01 , USART_MODER :: HW_HANDSHAKING => 0x02 , USART_MODER :: IS07816_T_0 => 0x04 , USART_MODER :: IS07816_T_1 => 0x06 , USART_MODER :: IRDA => 0x08 , USART_MODER :: LIN_MASTER => 0x0a , USART_MODER :: LIN_SLAVE => 0x0b , USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 0 => USART_MODER :: NORMAL , 1 => USART_MODER :: RS485 , 2 => USART_MODER :: HW_HANDSHAKING , 4 => USART_MODER :: IS07816_T_0 , 6 => USART_MODER :: IS07816_T_1 , 8 => USART_MODER :: IRDA , 10 => USART_MODER :: LIN_MASTER , 11 => USART_MODER :: LIN_SLAVE , 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == USART_MODER :: NORMAL } # [ doc = "Checks if the value of the field is `RS485`" ] # [ inline ] pub fn is_rs485 ( & self ) -> bool { * self == USART_MODER :: RS485 } # [ doc = "Checks if the value of the field is `HW_HANDSHAKING`" ] # [ inline ] pub fn is_hw_handshaking ( & self ) -> bool { * self == USART_MODER :: HW_HANDSHAKING } # [ doc = "Checks if the value of the field is `IS07816_T_0`" ] # [ inline ] pub fn is_is07816_t_0 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_0 } # [ doc = "Checks if the value of the field is `IS07816_T_1`" ] # [ inline ] pub fn is_is07816_t_1 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_1 } # [ doc = "Checks if the value of the field is `IRDA`" ] # [ inline ] pub fn is_irda ( & self ) -> bool { * self == USART_MODER :: IRDA } # [ doc = "Checks if the value of the field is `LIN_MASTER`" ] # [ inline ] pub fn is_lin_master ( & self ) -> bool { * self == USART_MODER :: LIN_MASTER } # [ doc = "Checks if the value of the field is `LIN_SLAVE`" ] # [ inline ] pub fn is_lin_slave ( & self ) -> bool { * self == USART_MODER :: LIN_SLAVE } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _5_BIT => 0 , CHRLR :: _6_BIT => 0x01 , CHRLR :: _7_BIT => 0x02 , CHRLR :: _8_BIT => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 0 => CHRLR :: _5_BIT , 1 => CHRLR :: _6_BIT , 2 => CHRLR :: _7_BIT , 3 => CHRLR :: _8_BIT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_5_BIT`" ] # [ inline ] pub fn is_5_bit ( & self ) -> bool { * self == CHRLR :: _5_BIT } # [ doc = "Checks if the value of the field is `_6_BIT`" ] # [ inline ] pub fn is_6_bit ( & self ) -> bool { * self == CHRLR :: _6_BIT } # [ doc = "Checks if the value of the field is `_7_BIT`" ] # [ inline ] pub fn is_7_bit ( & self ) -> bool { * self == CHRLR :: _7_BIT } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_BIT } } # [ doc = r" Value of the field" ] pub struct SYNCR { bits : bool , } impl SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PAR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PARR { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PARR :: EVEN => 0 , PARR :: ODD => 0x01 , PARR :: SPACE => 0x02 , PARR :: MARK => 0x03 , PARR :: NO => 0x04 , PARR :: MULTIDROP => 0x06 , PARR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PARR { match value { 0 => PARR :: EVEN , 1 => PARR :: ODD , 2 => PARR :: SPACE , 3 => PARR :: MARK , 4 => PARR :: NO , 6 => PARR :: MULTIDROP , i => PARR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `EVEN`" ] # [ inline ] pub fn is_even ( & self ) -> bool { * self == PARR :: EVEN } # [ doc = "Checks if the value of the field is `ODD`" ] # [ inline ] pub fn is_odd ( & self ) -> bool { * self == PARR :: ODD } # [ doc = "Checks if the value of the field is `SPACE`" ] # [ inline ] pub fn is_space ( & self ) -> bool { * self == PARR :: SPACE } # [ doc = "Checks if the value of the field is `MARK`" ] # [ inline ] pub fn is_mark ( & self ) -> bool { * self == PARR :: MARK } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == PARR :: NO } # [ doc = "Checks if the value of the field is `MULTIDROP`" ] # [ inline ] pub fn is_multidrop ( & self ) -> bool { * self == PARR :: MULTIDROP } } # [ doc = "Possible values of the field `NBSTOP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBSTOPR { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBSTOPR :: _1_BIT => 0 , NBSTOPR :: _1_5_BIT => 0x01 , NBSTOPR :: _2_BIT => 0x02 , NBSTOPR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBSTOPR { match value { 0 => NBSTOPR :: _1_BIT , 1 => NBSTOPR :: _1_5_BIT , 2 => NBSTOPR :: _2_BIT , i => NBSTOPR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1_BIT`" ] # [ inline ] pub fn is_1_bit ( & self ) -> bool { * self == NBSTOPR :: _1_BIT } # [ doc = "Checks if the value of the field is `_1_5_BIT`" ] # [ inline ] pub fn is_1_5_bit ( & self ) -> bool { * self == NBSTOPR :: _1_5_BIT } # [ doc = "Checks if the value of the field is `_2_BIT`" ] # [ inline ] pub fn is_2_bit ( & self ) -> bool { * self == NBSTOPR :: _2_BIT } } # [ doc = "Possible values of the field `CHMODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHMODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHMODER :: NORMAL => 0 , CHMODER :: AUTOMATIC => 0x01 , CHMODER :: LOCAL_LOOPBACK => 0x02 , CHMODER :: REMOTE_LOOPBACK => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHMODER { match value { 0 => CHMODER :: NORMAL , 1 => CHMODER :: AUTOMATIC , 2 => CHMODER :: LOCAL_LOOPBACK , 3 => CHMODER :: REMOTE_LOOPBACK , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == CHMODER :: NORMAL } # [ doc = "Checks if the value of the field is `AUTOMATIC`" ] # [ inline ] pub fn is_automatic ( & self ) -> bool { * self == CHMODER :: AUTOMATIC } # [ doc = "Checks if the value of the field is `LOCAL_LOOPBACK`" ] # [ inline ] pub fn is_local_loopback ( & self ) -> bool { * self == CHMODER :: LOCAL_LOOPBACK } # [ doc = "Checks if the value of the field is `REMOTE_LOOPBACK`" ] # [ inline ] pub fn is_remote_loopback ( & self ) -> bool { * self == CHMODER :: REMOTE_LOOPBACK } } # [ doc = r" Value of the field" ] pub struct MSBFR { bits : bool , } impl MSBFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODE9R { bits : bool , } impl MODE9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKOR { bits : bool , } impl CLKOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERR { bits : bool , } impl OVERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INACKR { bits : bool , } impl INACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSNACKR { bits : bool , } impl DSNACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VAR_SYNCR { bits : bool , } impl VAR_SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVDATAR { bits : bool , } impl INVDATAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MAX_ITERATIONR { bits : u8 , } impl MAX_ITERATIONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FILTERR { bits : bool , } impl FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANR { bits : bool , } impl MANR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODSYNCR { bits : bool , } impl MODSYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: NORMAL => 0 , USART_MODEW :: RS485 => 1 , USART_MODEW :: HW_HANDSHAKING => 2 , USART_MODEW :: IS07816_T_0 => 4 , USART_MODEW :: IS07816_T_1 => 6 , USART_MODEW :: IRDA => 8 , USART_MODEW :: LIN_MASTER => 10 , USART_MODEW :: LIN_SLAVE => 11 , USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: NORMAL ) } # [ doc = "RS485" ] # [ inline ] pub fn rs485 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: RS485 ) } # [ doc = "Hardware Handshaking" ] # [ inline ] pub fn hw_handshaking ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: HW_HANDSHAKING ) } # [ doc = "IS07816 Protocol: T = 0" ] # [ inline ] pub fn is07816_t_0 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_0 ) } # [ doc = "IS07816 Protocol: T = 1" ] # [ inline ] pub fn is07816_t_1 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_1 ) } # [ doc = "IrDA" ] # [ inline ] pub fn irda ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IRDA ) } # [ doc = "LIN master" ] # [ inline ] pub fn lin_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_MASTER ) } # [ doc = "LIN Slave" ] # [ inline ] pub fn lin_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_SLAVE ) } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _5_BIT => 0 , CHRLW :: _6_BIT => 1 , CHRLW :: _7_BIT => 2 , CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 5 bits" ] # [ inline ] pub fn _5_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _5_BIT ) } # [ doc = "Character length is 6 bits" ] # [ inline ] pub fn _6_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _6_BIT ) } # [ doc = "Character length is 7 bits" ] # [ inline ] pub fn _7_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _7_BIT ) } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PAR`" ] pub enum PARW { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP } impl PARW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PARW :: EVEN => 0 , PARW :: ODD => 1 , PARW :: SPACE => 2 , PARW :: MARK => 3 , PARW :: NO => 4 , PARW :: MULTIDROP => 6 } } } # [ doc = r" Proxy" ] pub struct _PARW < 'a > { w : & 'a mut W , } impl < 'a > _PARW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PARW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Even parity" ] # [ inline ] pub fn even ( self ) -> & 'a mut W { self . variant ( PARW :: EVEN ) } # [ doc = "Odd parity" ] # [ inline ] pub fn odd ( self ) -> & 'a mut W { self . variant ( PARW :: ODD ) } # [ doc = "Parity forced to 0 (Space)" ] # [ inline ] pub fn space ( self ) -> & 'a mut W { self . variant ( PARW :: SPACE ) } # [ doc = "Parity forced to 1 (Mark)" ] # [ inline ] pub fn mark ( self ) -> & 'a mut W { self . variant ( PARW :: MARK ) } # [ doc = "No parity" ] # [ inline ] pub fn no ( self ) -> & 'a mut W { self . variant ( PARW :: NO ) } # [ doc = "Multidrop mode" ] # [ inline ] pub fn multidrop ( self ) -> & 'a mut W { self . variant ( PARW :: MULTIDROP ) } # [ 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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `NBSTOP`" ] pub enum NBSTOPW { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT } impl NBSTOPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NBSTOPW :: _1_BIT => 0 , NBSTOPW :: _1_5_BIT => 1 , NBSTOPW :: _2_BIT => 2 } } } # [ doc = r" Proxy" ] pub struct _NBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _NBSTOPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NBSTOPW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 stop bit" ] # [ inline ] pub fn _1_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_BIT ) } # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] # [ inline ] pub fn _1_5_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_5_BIT ) } # [ doc = "2 stop bits" ] # [ inline ] pub fn _2_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _2_BIT ) } # [ 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 = "Values that can be written to the field `CHMODE`" ] pub enum CHMODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHMODEW :: NORMAL => 0 , CHMODEW :: AUTOMATIC => 1 , CHMODEW :: LOCAL_LOOPBACK => 2 , CHMODEW :: REMOTE_LOOPBACK => 3 } } } # [ doc = r" Proxy" ] pub struct _CHMODEW < 'a > { w : & 'a mut W , } impl < 'a > _CHMODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHMODEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( CHMODEW :: NORMAL ) } # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] # [ inline ] pub fn automatic ( self ) -> & 'a mut W { self . variant ( CHMODEW :: AUTOMATIC ) } # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] # [ inline ] pub fn local_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: LOCAL_LOOPBACK ) } # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] # [ inline ] pub fn remote_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: REMOTE_LOOPBACK ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _MSBFW < 'a > { w : & 'a mut W , } impl < 'a > _MSBFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODE9W < 'a > { w : & 'a mut W , } impl < 'a > _MODE9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CLKOW < 'a > { w : & 'a mut W , } impl < 'a > _CLKOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERW < 'a > { w : & 'a mut W , } impl < 'a > _OVERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INACKW < 'a > { w : & 'a mut W , } impl < 'a > _INACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSNACKW < 'a > { w : & 'a mut W , } impl < 'a > _DSNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VAR_SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _VAR_SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVDATAW < 'a > { w : & 'a mut W , } impl < 'a > _INVDATAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MAX_ITERATIONW < 'a > { w : & 'a mut W , } impl < 'a > _MAX_ITERATIONW < '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 _FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _FILTERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANW < 'a > { w : & 'a mut W , } impl < 'a > _MANW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODSYNCW < 'a > { w : & 'a mut W , } impl < 'a > _MODSYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 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:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & self ) -> SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNCR { bits } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & self ) -> PARR { PARR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & self ) -> NBSTOPR { NBSTOPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & self ) -> CHMODER { CHMODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & self ) -> MSBFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSBFR { bits } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & self ) -> MODE9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODE9R { bits } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & self ) -> CLKOR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKOR { bits } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & self ) -> OVERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERR { bits } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & self ) -> INACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INACKR { bits } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & self ) -> DSNACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSNACKR { bits } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & self ) -> VAR_SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VAR_SYNCR { bits } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & self ) -> INVDATAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVDATAR { bits } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & self ) -> MAX_ITERATIONR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MAX_ITERATIONR { bits } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & self ) -> FILTERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FILTERR { bits } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & self ) -> MANR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANR { bits } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & self ) -> MODSYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODSYNCR { bits } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & self ) -> ONEBITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONEBITR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & mut self ) -> _SYNCW { _SYNCW { w : self } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & mut self ) -> _PARW { _PARW { w : self } } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & mut self ) -> _NBSTOPW { _NBSTOPW { w : self } } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & mut self ) -> _CHMODEW { _CHMODEW { w : self } } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & mut self ) -> _MSBFW { _MSBFW { w : self } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & mut self ) -> _MODE9W { _MODE9W { w : self } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & mut self ) -> _CLKOW { _CLKOW { w : self } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & mut self ) -> _OVERW { _OVERW { w : self } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & mut self ) -> _INACKW { _INACKW { w : self } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & mut self ) -> _DSNACKW { _DSNACKW { w : self } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & mut self ) -> _VAR_SYNCW { _VAR_SYNCW { w : self } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & mut self ) -> _INVDATAW { _INVDATAW { w : self } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & mut self ) -> _MAX_ITERATIONW { _MAX_ITERATIONW { w : self } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & mut self ) -> _FILTERW { _FILTERW { w : self } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & mut self ) -> _MANW { _MANW { w : self } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & mut self ) -> _MODSYNCW { _MODSYNCW { w : self } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & mut self ) -> _ONEBITW { _ONEBITW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr_spi_mode { # [ 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 :: MR_SPI_MODE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 8 bits" ] _8_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _8_BIT => 0x03 , CHRLR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 3 => CHRLR :: _8_BIT , i => CHRLR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_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 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 WRDBTR { bits : bool , } impl WRDBTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ 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 _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 = 8 ; 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _WRDBTW < 'a > { w : & 'a mut W , } impl < 'a > _WRDBTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & self ) -> CPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPHAR { bits } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & self ) -> WRDBTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WRDBTR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & mut self ) -> _CPHAW { _CPHAW { w : self } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & mut self ) -> _WRDBTW { _WRDBTW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Enable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max number of Repetitions Reached Interrupt Enable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Enable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Enable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Enable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Enable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Enable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Enable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Enable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Enable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Enable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Enable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Enable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Enable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Disable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Disable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Disable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Disable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Disable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Disable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Disable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Disable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Disable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Disable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Disable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Disable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Disable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Disable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANER { bits : bool , } impl MANER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Receiver Break Interrupt Mask" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmit Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Mask" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Buffer Empty Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Buffer Full Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Mask" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Mask" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 24 - Manchester Error Interrupt Mask" ] # [ inline ] pub fn mane ( & self ) -> MANER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANER { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Mask" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Mask" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Mask" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Mask" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Mask" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Mask" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Mask" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Mask" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Mask" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 MANERRR { bits : bool , } impl MANERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Break Received/End of Break" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receiver Transfer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmitter Transfer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Transmission Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Reception Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Flag" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 23 - Image of CTS Input" ] # [ inline ] pub fn cts ( & self ) -> CTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSR { bits } } # [ doc = "Bit 24 - Manchester Error" ] # [ inline ] pub fn manerr ( & self ) -> MANERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANERRR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Underrun Error" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBLSR { bits : bool , } impl LINBLSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 23 - LIN Bus Line Status" ] # [ inline ] pub fn linbls ( & self ) -> LINBLSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBLSR { bits } } # [ doc = "Bit 25 - LIN Bit Error" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Error" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 RXCHRR { bits : u16 , } impl RXCHRR { # [ 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 RXSYNHR { bits : bool , } impl RXSYNHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:8 - Received Character" ] # [ inline ] pub fn rxchr ( & self ) -> RXCHRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCHRR { bits } } # [ doc = "Bit 15 - Received Sync" ] # [ inline ] pub fn rxsynh ( & self ) -> RXSYNHR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSYNHR { bits } } } } # [ doc = "Transmit Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCHRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCHRW < '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 } } # [ doc = r" Proxy" ] pub struct _TXSYNHW < 'a > { w : & 'a mut W , } impl < 'a > _TXSYNHW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:8 - Character to be Transmitted" ] # [ inline ] pub fn txchr ( & mut self ) -> _TXCHRW { _TXCHRW { w : self } } # [ doc = "Bit 15 - Sync Field to be Transmitted" ] # [ inline ] pub fn txsynh ( & mut self ) -> _TXSYNHW { _TXSYNHW { w : self } } } } # [ doc = "Baud Rate Generator Register" ] pub struct BRGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Baud Rate Generator Register" ] pub mod brgr { # [ 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 :: BRGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDR { bits : u16 , } impl CDR { # [ 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 FPR { bits : u8 , } impl FPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDW < 'a > { w : & 'a mut W , } impl < 'a > _CDW < '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 } } # [ doc = r" Proxy" ] pub struct _FPW < 'a > { w : & 'a mut W , } impl < 'a > _FPW < '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 = 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:15 - Clock Divider" ] # [ inline ] pub fn cd ( & self ) -> CDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; CDR { bits } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & self ) -> FPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPR { 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 - Clock Divider" ] # [ inline ] pub fn cd ( & mut self ) -> _CDW { _CDW { w : self } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & mut self ) -> _FPW { _FPW { w : self } } } } # [ doc = "Receiver Time-out Register" ] pub struct RTOR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receiver Time-out 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 < F > ( & 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 < F > ( & 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 TOR { bits : u32 , } impl TOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TOW < 'a > { w : & 'a mut W , } impl < 'a > _TOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0001_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:16 - Time-out Value" ] # [ inline ] pub fn to ( & self ) -> TOR { let bits = { const MASK : u32 = 0x0001_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TOR { 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:16 - Time-out Value" ] # [ inline ] pub fn to ( & mut self ) -> _TOW { _TOW { w : self } } } } # [ doc = "Transmitter Timeguard Register" ] pub struct TTGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmitter Timeguard Register" ] pub mod ttgr { # [ 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 :: TTGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TGR { bits : u8 , } impl TGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _TGW < 'a > { w : & 'a mut W , } impl < 'a > _TGW < '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 - Timeguard Value" ] # [ inline ] pub fn tg ( & self ) -> TGR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TGR { 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 - Timeguard Value" ] # [ inline ] pub fn tg ( & mut self ) -> _TGW { _TGW { w : self } } } } # [ doc = "FI DI Ratio Register" ] pub struct FIDI { register : :: vcell :: VolatileCell < u32 > } # [ doc = "FI DI Ratio Register" ] pub mod fidi { # [ 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 :: FIDI { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FI_DI_RATIOR { bits : u16 , } impl FI_DI_RATIOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _FI_DI_RATIOW < 'a > { w : & 'a mut W , } impl < 'a > _FI_DI_RATIOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & self ) -> FI_DI_RATIOR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; FI_DI_RATIOR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0174 } } # [ 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & mut self ) -> _FI_DI_RATIOW { _FI_DI_RATIOW { w : self } } } } # [ doc = "Number of Errors Register" ] pub struct NER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Number of Errors Register" ] pub mod ner { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: NER { # [ 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 NB_ERRORSR { bits : u8 , } impl NB_ERRORSR { # [ 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 - Number of Errors" ] # [ inline ] pub fn nb_errors ( & self ) -> NB_ERRORSR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NB_ERRORSR { bits } } } } # [ doc = "IrDA Filter Register" ] pub struct IF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "IrDA Filter Register" ] pub mod if_ { # [ 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 :: IF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IRDA_FILTERR { bits : u8 , } impl IRDA_FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IRDA_FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _IRDA_FILTERW < '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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & self ) -> IRDA_FILTERR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IRDA_FILTERR { 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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & mut self ) -> _IRDA_FILTERW { _IRDA_FILTERW { w : self } } } } # [ doc = "Manchester Configuration Register" ] pub struct MAN { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Manchester Configuration Register" ] pub mod man { # [ 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 :: MAN { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TX_PLR { bits : u8 , } impl TX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `TX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TX_PPR :: ALL_ONE => 0 , TX_PPR :: ALL_ZERO => 0x01 , TX_PPR :: ZERO_ONE => 0x02 , TX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TX_PPR { match value { 0 => TX_PPR :: ALL_ONE , 1 => TX_PPR :: ALL_ZERO , 2 => TX_PPR :: ZERO_ONE , 3 => TX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == TX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == TX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == TX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == TX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct TX_MPOLR { bits : bool , } impl TX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RX_PLR { bits : u8 , } impl RX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `RX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RX_PPR :: ALL_ONE => 0 , RX_PPR :: ALL_ZERO => 0x01 , RX_PPR :: ZERO_ONE => 0x02 , RX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RX_PPR { match value { 0 => RX_PPR :: ALL_ONE , 1 => RX_PPR :: ALL_ZERO , 2 => RX_PPR :: ZERO_ONE , 3 => RX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == RX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == RX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == RX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == RX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct RX_MPOLR { bits : bool , } impl RX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ONER { bits : bool , } impl ONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRIFTR { bits : bool , } impl DRIFTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PLW < '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 } } # [ doc = "Values that can be written to the field `TX_PP`" ] pub enum TX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TX_PPW :: ALL_ONE => 0 , TX_PPW :: ALL_ZERO => 1 , TX_PPW :: ZERO_ONE => 2 , TX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _TX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _TX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PLW < '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 = "Values that can be written to the field `RX_PP`" ] pub enum RX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RX_PPW :: ALL_ONE => 0 , RX_PPW :: ALL_ZERO => 1 , RX_PPW :: ZERO_ONE => 2 , RX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _RX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _RX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ONEW < 'a > { w : & 'a mut W , } impl < 'a > _ONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRIFTW < 'a > { w : & 'a mut W , } impl < 'a > _DRIFTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & self ) -> TX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TX_PLR { bits } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & self ) -> TX_PPR { TX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & self ) -> TX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TX_MPOLR { bits } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & self ) -> RX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RX_PLR { bits } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & self ) -> RX_PPR { RX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & self ) -> RX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RX_MPOLR { bits } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & self ) -> ONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONER { bits } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & self ) -> DRIFTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRIFTR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0xb001_1004 } } # [ 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 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & mut self ) -> _TX_PLW { _TX_PLW { w : self } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & mut self ) -> _TX_PPW { _TX_PPW { w : self } } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & mut self ) -> _TX_MPOLW { _TX_MPOLW { w : self } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & mut self ) -> _RX_PLW { _RX_PLW { w : self } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & mut self ) -> _RX_PPW { _RX_PPW { w : self } } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & mut self ) -> _RX_MPOLW { _RX_MPOLW { w : self } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & mut self ) -> _ONEW { _ONEW { w : self } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & mut self ) -> _DRIFTW { _DRIFTW { w : self } } } } # [ doc = "LIN Mode Register" ] pub struct LINMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Mode Register" ] pub mod linmr { # [ 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 :: LINMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `NACT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NACTR { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NACTR :: PUBLISH => 0 , NACTR :: SUBSCRIBE => 0x01 , NACTR :: IGNORE => 0x02 , NACTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NACTR { match value { 0 => NACTR :: PUBLISH , 1 => NACTR :: SUBSCRIBE , 2 => NACTR :: IGNORE , i => NACTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PUBLISH`" ] # [ inline ] pub fn is_publish ( & self ) -> bool { * self == NACTR :: PUBLISH } # [ doc = "Checks if the value of the field is `SUBSCRIBE`" ] # [ inline ] pub fn is_subscribe ( & self ) -> bool { * self == NACTR :: SUBSCRIBE } # [ doc = "Checks if the value of the field is `IGNORE`" ] # [ inline ] pub fn is_ignore ( & self ) -> bool { * self == NACTR :: IGNORE } } # [ doc = r" Value of the field" ] pub struct PARDISR { bits : bool , } impl PARDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKDISR { bits : bool , } impl CHKDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKTYPR { bits : bool , } impl CHKTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLMR { bits : bool , } impl DLMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSDISR { bits : bool , } impl FSDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WKUPTYPR { bits : bool , } impl WKUPTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLCR { bits : u8 , } impl DLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PDCMR { bits : bool , } impl PDCMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `NACT`" ] pub enum NACTW { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE } impl NACTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NACTW :: PUBLISH => 0 , NACTW :: SUBSCRIBE => 1 , NACTW :: IGNORE => 2 } } } # [ doc = r" Proxy" ] pub struct _NACTW < 'a > { w : & 'a mut W , } impl < 'a > _NACTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NACTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The USART transmits the response." ] # [ inline ] pub fn publish ( self ) -> & 'a mut W { self . variant ( NACTW :: PUBLISH ) } # [ doc = "The USART receives the response." ] # [ inline ] pub fn subscribe ( self ) -> & 'a mut W { self . variant ( NACTW :: SUBSCRIBE ) } # [ doc = "The USART does not transmit and does not receive the response." ] # [ inline ] pub fn ignore ( self ) -> & 'a mut W { self . variant ( NACTW :: IGNORE ) } # [ 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 _PARDISW < 'a > { w : & 'a mut W , } impl < 'a > _PARDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CHKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKTYPW < 'a > { w : & 'a mut W , } impl < 'a > _CHKTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLMW < 'a > { w : & 'a mut W , } impl < 'a > _DLMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSDISW < 'a > { w : & 'a mut W , } impl < 'a > _FSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WKUPTYPW < 'a > { w : & 'a mut W , } impl < 'a > _WKUPTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLCW < 'a > { w : & 'a mut W , } impl < 'a > _DLCW < '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 _PDCMW < 'a > { w : & 'a mut W , } impl < 'a > _PDCMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:1 - LIN Node Action" ] # [ inline ] pub fn nact ( & self ) -> NACTR { NACTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & self ) -> PARDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARDISR { bits } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & self ) -> CHKDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKDISR { bits } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & self ) -> CHKTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKTYPR { bits } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & self ) -> DLMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLMR { bits } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & self ) -> FSDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSDISR { bits } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & self ) -> WKUPTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WKUPTYPR { bits } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & self ) -> DLCR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DLCR { bits } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & self ) -> PDCMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PDCMR { 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 - LIN Node Action" ] # [ inline ] pub fn nact ( & mut self ) -> _NACTW { _NACTW { w : self } } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & mut self ) -> _PARDISW { _PARDISW { w : self } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & mut self ) -> _CHKDISW { _CHKDISW { w : self } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & mut self ) -> _CHKTYPW { _CHKTYPW { w : self } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & mut self ) -> _DLMW { _DLMW { w : self } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & mut self ) -> _FSDISW { _FSDISW { w : self } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & mut self ) -> _WKUPTYPW { _WKUPTYPW { w : self } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & mut self ) -> _DLCW { _DLCW { w : self } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & mut self ) -> _PDCMW { _PDCMW { w : self } } } } # [ doc = "LIN Identifier Register" ] pub struct LINIR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Identifier Register" ] pub mod linir { # [ 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 :: LINIR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IDCHRR { bits : u8 , } impl IDCHRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IDCHRW < 'a > { w : & 'a mut W , } impl < 'a > _IDCHRW < '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 - Identifier Character" ] # [ inline ] pub fn idchr ( & self ) -> IDCHRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IDCHRR { 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 - Identifier Character" ] # [ inline ] pub fn idchr ( & mut self ) -> _IDCHRW { _IDCHRW { w : self } } } } # [ doc = "LIN Baud Rate Register" ] pub struct LINBRR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Baud Rate Register" ] pub mod linbrr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LINBRR { # [ 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 LINCDR { bits : u16 , } impl LINCDR { # [ 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 LINFPR { bits : u8 , } impl LINFPR { # [ 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:15 - Clock Divider after Synchronization" ] # [ inline ] pub fn lincd ( & self ) -> LINCDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; LINCDR { bits } } # [ doc = "Bits 16:18 - Fractional Part after Synchronization" ] # [ inline ] pub fn linfp ( & self ) -> LINFPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; LINFPR { bits } } } } # [ doc = "Write Protection Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0055_5341 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5591873 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5591873 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protection Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 1" ] 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 { 0x4009_c000 as * const _ } } impl Deref for USART1 { type Target = usart1 :: RegisterBlock ; fn deref ( & self ) -> & usart1 :: RegisterBlock { unsafe { & * USART1 :: ptr ( ) } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 1" ] pub mod usart1 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "Control Register" ] pub cr : CR_UNION , # [ doc = "Mode Register" ] pub mr : MR_UNION , # [ doc = "Interrupt Enable Register" ] pub ier : IER_UNION , # [ doc = "Interrupt Disable Register" ] pub idr : IDR_UNION , # [ doc = "Interrupt Mask Register" ] pub imr : IMR_UNION , # [ doc = "Channel Status Register" ] pub csr : CSR_UNION , # [ doc = "0x18 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x1c - Transmit Holding Register" ] pub thr : THR , # [ doc = "0x20 - Baud Rate Generator Register" ] pub brgr : BRGR , # [ doc = "0x24 - Receiver Time-out Register" ] pub rtor : RTOR , # [ doc = "0x28 - Transmitter Timeguard Register" ] pub ttgr : TTGR , _reserved11 : [ u8 ; 20usize ] , # [ doc = "0x40 - FI DI Ratio Register" ] pub fidi : FIDI , # [ doc = "0x44 - Number of Errors Register" ] pub ner : NER , _reserved13 : [ u8 ; 4usize ] , # [ doc = "0x4c - IrDA Filter Register" ] pub if_ : IF , # [ doc = "0x50 - Manchester Configuration Register" ] pub man : MAN , # [ doc = "0x54 - LIN Mode Register" ] pub linmr : LINMR , # [ doc = "0x58 - LIN Identifier Register" ] pub linir : LINIR , # [ doc = "0x5c - LIN Baud Rate Register" ] pub linbrr : LINBRR , _reserved18 : [ u8 ; 132usize ] , # [ doc = "0xe4 - Write Protection Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protection Status Register" ] pub wpsr : WPSR , _reserved20 : [ u8 ; 20usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] # [ repr ( C ) ] pub union CR_UNION { # [ doc = "0x00 - Control Register" ] pub cr_spi_mode : CR_SPI_MODE , # [ doc = "0x00 - Control Register" ] pub cr : CR , } # [ doc = "Mode Register" ] # [ repr ( C ) ] pub union MR_UNION { # [ doc = "0x04 - Mode Register" ] pub mr_spi_mode : MR_SPI_MODE , # [ doc = "0x04 - Mode Register" ] pub mr : MR , } # [ doc = "Interrupt Enable Register" ] # [ repr ( C ) ] pub union IER_UNION { # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_lin_mode : IER_LIN_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_spi_mode : IER_SPI_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier : IER , } # [ doc = "Interrupt Disable Register" ] # [ repr ( C ) ] pub union IDR_UNION { # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_lin_mode : IDR_LIN_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_spi_mode : IDR_SPI_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr : IDR , } # [ doc = "Interrupt Mask Register" ] # [ repr ( C ) ] pub union IMR_UNION { # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_lin_mode : IMR_LIN_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_spi_mode : IMR_SPI_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr : IMR , } # [ doc = "Channel Status Register" ] # [ repr ( C ) ] pub union CSR_UNION { # [ doc = "0x14 - Channel Status Register" ] pub csr_lin_mode : CSR_LIN_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr_spi_mode : CSR_SPI_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr : CSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STTBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STPBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STPBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTTOW < 'a > { w : & 'a mut W , } impl < 'a > _STTTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SENDAW < 'a > { w : & 'a mut W , } impl < 'a > _SENDAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTITW < 'a > { w : & 'a mut W , } impl < 'a > _RSTITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTNACKW < 'a > { w : & 'a mut W , } impl < 'a > _RSTNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RETTOW < 'a > { w : & 'a mut W , } impl < 'a > _RETTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSENW < 'a > { w : & 'a mut W , } impl < 'a > _RTSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSDISW < 'a > { w : & 'a mut W , } impl < 'a > _RTSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINABTW < 'a > { w : & 'a mut W , } impl < 'a > _LINABTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINWKUPW < 'a > { w : & 'a mut W , } impl < 'a > _LINWKUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 9 - Start Break" ] # [ inline ] pub fn sttbrk ( & mut self ) -> _STTBRKW { _STTBRKW { w : self } } # [ doc = "Bit 10 - Stop Break" ] # [ inline ] pub fn stpbrk ( & mut self ) -> _STPBRKW { _STPBRKW { w : self } } # [ doc = "Bit 11 - Start Time-out" ] # [ inline ] pub fn sttto ( & mut self ) -> _STTTOW { _STTTOW { w : self } } # [ doc = "Bit 12 - Send Address" ] # [ inline ] pub fn senda ( & mut self ) -> _SENDAW { _SENDAW { w : self } } # [ doc = "Bit 13 - Reset Iterations" ] # [ inline ] pub fn rstit ( & mut self ) -> _RSTITW { _RSTITW { w : self } } # [ doc = "Bit 14 - Reset Non Acknowledge" ] # [ inline ] pub fn rstnack ( & mut self ) -> _RSTNACKW { _RSTNACKW { w : self } } # [ doc = "Bit 15 - Rearm Time-out" ] # [ inline ] pub fn retto ( & mut self ) -> _RETTOW { _RETTOW { w : self } } # [ doc = "Bit 18 - Request to Send Enable" ] # [ inline ] pub fn rtsen ( & mut self ) -> _RTSENW { _RTSENW { w : self } } # [ doc = "Bit 19 - Request to Send Disable" ] # [ inline ] pub fn rtsdis ( & mut self ) -> _RTSDISW { _RTSDISW { w : self } } # [ doc = "Bit 20 - Abort LIN Transmission" ] # [ inline ] pub fn linabt ( & mut self ) -> _LINABTW { _LINABTW { w : self } } # [ doc = "Bit 21 - Send LIN Wakeup Signal" ] # [ inline ] pub fn linwkup ( & mut self ) -> _LINWKUPW { _LINWKUPW { w : self } } } } # [ doc = "Control Register" ] pub struct CR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCSW < 'a > { w : & 'a mut W , } impl < 'a > _FCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCSW < 'a > { w : & 'a mut W , } impl < 'a > _RCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 18 - Force SPI Chip Select" ] # [ inline ] pub fn fcs ( & mut self ) -> _FCSW { _FCSW { w : self } } # [ doc = "Bit 19 - Release SPI Chip Select" ] # [ inline ] pub fn rcs ( & mut self ) -> _RCSW { _RCSW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: NORMAL => 0 , USART_MODER :: RS485 => 0x01 , USART_MODER :: HW_HANDSHAKING => 0x02 , USART_MODER :: IS07816_T_0 => 0x04 , USART_MODER :: IS07816_T_1 => 0x06 , USART_MODER :: IRDA => 0x08 , USART_MODER :: LIN_MASTER => 0x0a , USART_MODER :: LIN_SLAVE => 0x0b , USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 0 => USART_MODER :: NORMAL , 1 => USART_MODER :: RS485 , 2 => USART_MODER :: HW_HANDSHAKING , 4 => USART_MODER :: IS07816_T_0 , 6 => USART_MODER :: IS07816_T_1 , 8 => USART_MODER :: IRDA , 10 => USART_MODER :: LIN_MASTER , 11 => USART_MODER :: LIN_SLAVE , 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == USART_MODER :: NORMAL } # [ doc = "Checks if the value of the field is `RS485`" ] # [ inline ] pub fn is_rs485 ( & self ) -> bool { * self == USART_MODER :: RS485 } # [ doc = "Checks if the value of the field is `HW_HANDSHAKING`" ] # [ inline ] pub fn is_hw_handshaking ( & self ) -> bool { * self == USART_MODER :: HW_HANDSHAKING } # [ doc = "Checks if the value of the field is `IS07816_T_0`" ] # [ inline ] pub fn is_is07816_t_0 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_0 } # [ doc = "Checks if the value of the field is `IS07816_T_1`" ] # [ inline ] pub fn is_is07816_t_1 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_1 } # [ doc = "Checks if the value of the field is `IRDA`" ] # [ inline ] pub fn is_irda ( & self ) -> bool { * self == USART_MODER :: IRDA } # [ doc = "Checks if the value of the field is `LIN_MASTER`" ] # [ inline ] pub fn is_lin_master ( & self ) -> bool { * self == USART_MODER :: LIN_MASTER } # [ doc = "Checks if the value of the field is `LIN_SLAVE`" ] # [ inline ] pub fn is_lin_slave ( & self ) -> bool { * self == USART_MODER :: LIN_SLAVE } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _5_BIT => 0 , CHRLR :: _6_BIT => 0x01 , CHRLR :: _7_BIT => 0x02 , CHRLR :: _8_BIT => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 0 => CHRLR :: _5_BIT , 1 => CHRLR :: _6_BIT , 2 => CHRLR :: _7_BIT , 3 => CHRLR :: _8_BIT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_5_BIT`" ] # [ inline ] pub fn is_5_bit ( & self ) -> bool { * self == CHRLR :: _5_BIT } # [ doc = "Checks if the value of the field is `_6_BIT`" ] # [ inline ] pub fn is_6_bit ( & self ) -> bool { * self == CHRLR :: _6_BIT } # [ doc = "Checks if the value of the field is `_7_BIT`" ] # [ inline ] pub fn is_7_bit ( & self ) -> bool { * self == CHRLR :: _7_BIT } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_BIT } } # [ doc = r" Value of the field" ] pub struct SYNCR { bits : bool , } impl SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PAR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PARR { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PARR :: EVEN => 0 , PARR :: ODD => 0x01 , PARR :: SPACE => 0x02 , PARR :: MARK => 0x03 , PARR :: NO => 0x04 , PARR :: MULTIDROP => 0x06 , PARR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PARR { match value { 0 => PARR :: EVEN , 1 => PARR :: ODD , 2 => PARR :: SPACE , 3 => PARR :: MARK , 4 => PARR :: NO , 6 => PARR :: MULTIDROP , i => PARR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `EVEN`" ] # [ inline ] pub fn is_even ( & self ) -> bool { * self == PARR :: EVEN } # [ doc = "Checks if the value of the field is `ODD`" ] # [ inline ] pub fn is_odd ( & self ) -> bool { * self == PARR :: ODD } # [ doc = "Checks if the value of the field is `SPACE`" ] # [ inline ] pub fn is_space ( & self ) -> bool { * self == PARR :: SPACE } # [ doc = "Checks if the value of the field is `MARK`" ] # [ inline ] pub fn is_mark ( & self ) -> bool { * self == PARR :: MARK } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == PARR :: NO } # [ doc = "Checks if the value of the field is `MULTIDROP`" ] # [ inline ] pub fn is_multidrop ( & self ) -> bool { * self == PARR :: MULTIDROP } } # [ doc = "Possible values of the field `NBSTOP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBSTOPR { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBSTOPR :: _1_BIT => 0 , NBSTOPR :: _1_5_BIT => 0x01 , NBSTOPR :: _2_BIT => 0x02 , NBSTOPR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBSTOPR { match value { 0 => NBSTOPR :: _1_BIT , 1 => NBSTOPR :: _1_5_BIT , 2 => NBSTOPR :: _2_BIT , i => NBSTOPR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1_BIT`" ] # [ inline ] pub fn is_1_bit ( & self ) -> bool { * self == NBSTOPR :: _1_BIT } # [ doc = "Checks if the value of the field is `_1_5_BIT`" ] # [ inline ] pub fn is_1_5_bit ( & self ) -> bool { * self == NBSTOPR :: _1_5_BIT } # [ doc = "Checks if the value of the field is `_2_BIT`" ] # [ inline ] pub fn is_2_bit ( & self ) -> bool { * self == NBSTOPR :: _2_BIT } } # [ doc = "Possible values of the field `CHMODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHMODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHMODER :: NORMAL => 0 , CHMODER :: AUTOMATIC => 0x01 , CHMODER :: LOCAL_LOOPBACK => 0x02 , CHMODER :: REMOTE_LOOPBACK => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHMODER { match value { 0 => CHMODER :: NORMAL , 1 => CHMODER :: AUTOMATIC , 2 => CHMODER :: LOCAL_LOOPBACK , 3 => CHMODER :: REMOTE_LOOPBACK , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == CHMODER :: NORMAL } # [ doc = "Checks if the value of the field is `AUTOMATIC`" ] # [ inline ] pub fn is_automatic ( & self ) -> bool { * self == CHMODER :: AUTOMATIC } # [ doc = "Checks if the value of the field is `LOCAL_LOOPBACK`" ] # [ inline ] pub fn is_local_loopback ( & self ) -> bool { * self == CHMODER :: LOCAL_LOOPBACK } # [ doc = "Checks if the value of the field is `REMOTE_LOOPBACK`" ] # [ inline ] pub fn is_remote_loopback ( & self ) -> bool { * self == CHMODER :: REMOTE_LOOPBACK } } # [ doc = r" Value of the field" ] pub struct MSBFR { bits : bool , } impl MSBFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODE9R { bits : bool , } impl MODE9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKOR { bits : bool , } impl CLKOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERR { bits : bool , } impl OVERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INACKR { bits : bool , } impl INACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSNACKR { bits : bool , } impl DSNACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VAR_SYNCR { bits : bool , } impl VAR_SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVDATAR { bits : bool , } impl INVDATAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MAX_ITERATIONR { bits : u8 , } impl MAX_ITERATIONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FILTERR { bits : bool , } impl FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANR { bits : bool , } impl MANR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODSYNCR { bits : bool , } impl MODSYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: NORMAL => 0 , USART_MODEW :: RS485 => 1 , USART_MODEW :: HW_HANDSHAKING => 2 , USART_MODEW :: IS07816_T_0 => 4 , USART_MODEW :: IS07816_T_1 => 6 , USART_MODEW :: IRDA => 8 , USART_MODEW :: LIN_MASTER => 10 , USART_MODEW :: LIN_SLAVE => 11 , USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: NORMAL ) } # [ doc = "RS485" ] # [ inline ] pub fn rs485 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: RS485 ) } # [ doc = "Hardware Handshaking" ] # [ inline ] pub fn hw_handshaking ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: HW_HANDSHAKING ) } # [ doc = "IS07816 Protocol: T = 0" ] # [ inline ] pub fn is07816_t_0 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_0 ) } # [ doc = "IS07816 Protocol: T = 1" ] # [ inline ] pub fn is07816_t_1 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_1 ) } # [ doc = "IrDA" ] # [ inline ] pub fn irda ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IRDA ) } # [ doc = "LIN master" ] # [ inline ] pub fn lin_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_MASTER ) } # [ doc = "LIN Slave" ] # [ inline ] pub fn lin_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_SLAVE ) } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _5_BIT => 0 , CHRLW :: _6_BIT => 1 , CHRLW :: _7_BIT => 2 , CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 5 bits" ] # [ inline ] pub fn _5_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _5_BIT ) } # [ doc = "Character length is 6 bits" ] # [ inline ] pub fn _6_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _6_BIT ) } # [ doc = "Character length is 7 bits" ] # [ inline ] pub fn _7_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _7_BIT ) } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PAR`" ] pub enum PARW { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP } impl PARW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PARW :: EVEN => 0 , PARW :: ODD => 1 , PARW :: SPACE => 2 , PARW :: MARK => 3 , PARW :: NO => 4 , PARW :: MULTIDROP => 6 } } } # [ doc = r" Proxy" ] pub struct _PARW < 'a > { w : & 'a mut W , } impl < 'a > _PARW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PARW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Even parity" ] # [ inline ] pub fn even ( self ) -> & 'a mut W { self . variant ( PARW :: EVEN ) } # [ doc = "Odd parity" ] # [ inline ] pub fn odd ( self ) -> & 'a mut W { self . variant ( PARW :: ODD ) } # [ doc = "Parity forced to 0 (Space)" ] # [ inline ] pub fn space ( self ) -> & 'a mut W { self . variant ( PARW :: SPACE ) } # [ doc = "Parity forced to 1 (Mark)" ] # [ inline ] pub fn mark ( self ) -> & 'a mut W { self . variant ( PARW :: MARK ) } # [ doc = "No parity" ] # [ inline ] pub fn no ( self ) -> & 'a mut W { self . variant ( PARW :: NO ) } # [ doc = "Multidrop mode" ] # [ inline ] pub fn multidrop ( self ) -> & 'a mut W { self . variant ( PARW :: MULTIDROP ) } # [ 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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `NBSTOP`" ] pub enum NBSTOPW { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT } impl NBSTOPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NBSTOPW :: _1_BIT => 0 , NBSTOPW :: _1_5_BIT => 1 , NBSTOPW :: _2_BIT => 2 } } } # [ doc = r" Proxy" ] pub struct _NBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _NBSTOPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NBSTOPW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 stop bit" ] # [ inline ] pub fn _1_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_BIT ) } # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] # [ inline ] pub fn _1_5_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_5_BIT ) } # [ doc = "2 stop bits" ] # [ inline ] pub fn _2_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _2_BIT ) } # [ 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 = "Values that can be written to the field `CHMODE`" ] pub enum CHMODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHMODEW :: NORMAL => 0 , CHMODEW :: AUTOMATIC => 1 , CHMODEW :: LOCAL_LOOPBACK => 2 , CHMODEW :: REMOTE_LOOPBACK => 3 } } } # [ doc = r" Proxy" ] pub struct _CHMODEW < 'a > { w : & 'a mut W , } impl < 'a > _CHMODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHMODEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( CHMODEW :: NORMAL ) } # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] # [ inline ] pub fn automatic ( self ) -> & 'a mut W { self . variant ( CHMODEW :: AUTOMATIC ) } # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] # [ inline ] pub fn local_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: LOCAL_LOOPBACK ) } # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] # [ inline ] pub fn remote_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: REMOTE_LOOPBACK ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _MSBFW < 'a > { w : & 'a mut W , } impl < 'a > _MSBFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODE9W < 'a > { w : & 'a mut W , } impl < 'a > _MODE9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CLKOW < 'a > { w : & 'a mut W , } impl < 'a > _CLKOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERW < 'a > { w : & 'a mut W , } impl < 'a > _OVERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INACKW < 'a > { w : & 'a mut W , } impl < 'a > _INACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSNACKW < 'a > { w : & 'a mut W , } impl < 'a > _DSNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VAR_SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _VAR_SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVDATAW < 'a > { w : & 'a mut W , } impl < 'a > _INVDATAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MAX_ITERATIONW < 'a > { w : & 'a mut W , } impl < 'a > _MAX_ITERATIONW < '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 _FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _FILTERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANW < 'a > { w : & 'a mut W , } impl < 'a > _MANW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODSYNCW < 'a > { w : & 'a mut W , } impl < 'a > _MODSYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 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:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & self ) -> SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNCR { bits } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & self ) -> PARR { PARR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & self ) -> NBSTOPR { NBSTOPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & self ) -> CHMODER { CHMODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & self ) -> MSBFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSBFR { bits } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & self ) -> MODE9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODE9R { bits } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & self ) -> CLKOR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKOR { bits } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & self ) -> OVERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERR { bits } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & self ) -> INACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INACKR { bits } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & self ) -> DSNACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSNACKR { bits } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & self ) -> VAR_SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VAR_SYNCR { bits } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & self ) -> INVDATAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVDATAR { bits } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & self ) -> MAX_ITERATIONR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MAX_ITERATIONR { bits } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & self ) -> FILTERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FILTERR { bits } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & self ) -> MANR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANR { bits } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & self ) -> MODSYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODSYNCR { bits } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & self ) -> ONEBITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONEBITR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & mut self ) -> _SYNCW { _SYNCW { w : self } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & mut self ) -> _PARW { _PARW { w : self } } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & mut self ) -> _NBSTOPW { _NBSTOPW { w : self } } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & mut self ) -> _CHMODEW { _CHMODEW { w : self } } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & mut self ) -> _MSBFW { _MSBFW { w : self } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & mut self ) -> _MODE9W { _MODE9W { w : self } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & mut self ) -> _CLKOW { _CLKOW { w : self } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & mut self ) -> _OVERW { _OVERW { w : self } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & mut self ) -> _INACKW { _INACKW { w : self } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & mut self ) -> _DSNACKW { _DSNACKW { w : self } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & mut self ) -> _VAR_SYNCW { _VAR_SYNCW { w : self } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & mut self ) -> _INVDATAW { _INVDATAW { w : self } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & mut self ) -> _MAX_ITERATIONW { _MAX_ITERATIONW { w : self } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & mut self ) -> _FILTERW { _FILTERW { w : self } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & mut self ) -> _MANW { _MANW { w : self } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & mut self ) -> _MODSYNCW { _MODSYNCW { w : self } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & mut self ) -> _ONEBITW { _ONEBITW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr_spi_mode { # [ 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 :: MR_SPI_MODE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 8 bits" ] _8_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _8_BIT => 0x03 , CHRLR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 3 => CHRLR :: _8_BIT , i => CHRLR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_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 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 WRDBTR { bits : bool , } impl WRDBTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ 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 _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 = 8 ; 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _WRDBTW < 'a > { w : & 'a mut W , } impl < 'a > _WRDBTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & self ) -> CPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPHAR { bits } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & self ) -> WRDBTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WRDBTR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & mut self ) -> _CPHAW { _CPHAW { w : self } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & mut self ) -> _WRDBTW { _WRDBTW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Enable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max number of Repetitions Reached Interrupt Enable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Enable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Enable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Enable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Enable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Enable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Enable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Enable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Enable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Enable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Enable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Enable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Enable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Disable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Disable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Disable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Disable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Disable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Disable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Disable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Disable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Disable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Disable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Disable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Disable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Disable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Disable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANER { bits : bool , } impl MANER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Receiver Break Interrupt Mask" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmit Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Mask" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Buffer Empty Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Buffer Full Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Mask" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Mask" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 24 - Manchester Error Interrupt Mask" ] # [ inline ] pub fn mane ( & self ) -> MANER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANER { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Mask" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Mask" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Mask" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Mask" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Mask" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Mask" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Mask" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Mask" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Mask" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 MANERRR { bits : bool , } impl MANERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Break Received/End of Break" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receiver Transfer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmitter Transfer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Transmission Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Reception Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Flag" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 23 - Image of CTS Input" ] # [ inline ] pub fn cts ( & self ) -> CTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSR { bits } } # [ doc = "Bit 24 - Manchester Error" ] # [ inline ] pub fn manerr ( & self ) -> MANERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANERRR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Underrun Error" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBLSR { bits : bool , } impl LINBLSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 23 - LIN Bus Line Status" ] # [ inline ] pub fn linbls ( & self ) -> LINBLSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBLSR { bits } } # [ doc = "Bit 25 - LIN Bit Error" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Error" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 RXCHRR { bits : u16 , } impl RXCHRR { # [ 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 RXSYNHR { bits : bool , } impl RXSYNHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:8 - Received Character" ] # [ inline ] pub fn rxchr ( & self ) -> RXCHRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCHRR { bits } } # [ doc = "Bit 15 - Received Sync" ] # [ inline ] pub fn rxsynh ( & self ) -> RXSYNHR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSYNHR { bits } } } } # [ doc = "Transmit Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCHRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCHRW < '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 } } # [ doc = r" Proxy" ] pub struct _TXSYNHW < 'a > { w : & 'a mut W , } impl < 'a > _TXSYNHW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:8 - Character to be Transmitted" ] # [ inline ] pub fn txchr ( & mut self ) -> _TXCHRW { _TXCHRW { w : self } } # [ doc = "Bit 15 - Sync Field to be Transmitted" ] # [ inline ] pub fn txsynh ( & mut self ) -> _TXSYNHW { _TXSYNHW { w : self } } } } # [ doc = "Baud Rate Generator Register" ] pub struct BRGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Baud Rate Generator Register" ] pub mod brgr { # [ 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 :: BRGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDR { bits : u16 , } impl CDR { # [ 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 FPR { bits : u8 , } impl FPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDW < 'a > { w : & 'a mut W , } impl < 'a > _CDW < '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 } } # [ doc = r" Proxy" ] pub struct _FPW < 'a > { w : & 'a mut W , } impl < 'a > _FPW < '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 = 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:15 - Clock Divider" ] # [ inline ] pub fn cd ( & self ) -> CDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; CDR { bits } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & self ) -> FPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPR { 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 - Clock Divider" ] # [ inline ] pub fn cd ( & mut self ) -> _CDW { _CDW { w : self } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & mut self ) -> _FPW { _FPW { w : self } } } } # [ doc = "Receiver Time-out Register" ] pub struct RTOR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receiver Time-out 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 < F > ( & 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 < F > ( & 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 TOR { bits : u32 , } impl TOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TOW < 'a > { w : & 'a mut W , } impl < 'a > _TOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0001_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:16 - Time-out Value" ] # [ inline ] pub fn to ( & self ) -> TOR { let bits = { const MASK : u32 = 0x0001_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TOR { 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:16 - Time-out Value" ] # [ inline ] pub fn to ( & mut self ) -> _TOW { _TOW { w : self } } } } # [ doc = "Transmitter Timeguard Register" ] pub struct TTGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmitter Timeguard Register" ] pub mod ttgr { # [ 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 :: TTGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TGR { bits : u8 , } impl TGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _TGW < 'a > { w : & 'a mut W , } impl < 'a > _TGW < '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 - Timeguard Value" ] # [ inline ] pub fn tg ( & self ) -> TGR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TGR { 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 - Timeguard Value" ] # [ inline ] pub fn tg ( & mut self ) -> _TGW { _TGW { w : self } } } } # [ doc = "FI DI Ratio Register" ] pub struct FIDI { register : :: vcell :: VolatileCell < u32 > } # [ doc = "FI DI Ratio Register" ] pub mod fidi { # [ 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 :: FIDI { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FI_DI_RATIOR { bits : u16 , } impl FI_DI_RATIOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _FI_DI_RATIOW < 'a > { w : & 'a mut W , } impl < 'a > _FI_DI_RATIOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & self ) -> FI_DI_RATIOR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; FI_DI_RATIOR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0174 } } # [ 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & mut self ) -> _FI_DI_RATIOW { _FI_DI_RATIOW { w : self } } } } # [ doc = "Number of Errors Register" ] pub struct NER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Number of Errors Register" ] pub mod ner { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: NER { # [ 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 NB_ERRORSR { bits : u8 , } impl NB_ERRORSR { # [ 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 - Number of Errors" ] # [ inline ] pub fn nb_errors ( & self ) -> NB_ERRORSR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NB_ERRORSR { bits } } } } # [ doc = "IrDA Filter Register" ] pub struct IF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "IrDA Filter Register" ] pub mod if_ { # [ 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 :: IF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IRDA_FILTERR { bits : u8 , } impl IRDA_FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IRDA_FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _IRDA_FILTERW < '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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & self ) -> IRDA_FILTERR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IRDA_FILTERR { 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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & mut self ) -> _IRDA_FILTERW { _IRDA_FILTERW { w : self } } } } # [ doc = "Manchester Configuration Register" ] pub struct MAN { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Manchester Configuration Register" ] pub mod man { # [ 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 :: MAN { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TX_PLR { bits : u8 , } impl TX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `TX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TX_PPR :: ALL_ONE => 0 , TX_PPR :: ALL_ZERO => 0x01 , TX_PPR :: ZERO_ONE => 0x02 , TX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TX_PPR { match value { 0 => TX_PPR :: ALL_ONE , 1 => TX_PPR :: ALL_ZERO , 2 => TX_PPR :: ZERO_ONE , 3 => TX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == TX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == TX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == TX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == TX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct TX_MPOLR { bits : bool , } impl TX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RX_PLR { bits : u8 , } impl RX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `RX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RX_PPR :: ALL_ONE => 0 , RX_PPR :: ALL_ZERO => 0x01 , RX_PPR :: ZERO_ONE => 0x02 , RX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RX_PPR { match value { 0 => RX_PPR :: ALL_ONE , 1 => RX_PPR :: ALL_ZERO , 2 => RX_PPR :: ZERO_ONE , 3 => RX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == RX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == RX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == RX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == RX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct RX_MPOLR { bits : bool , } impl RX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ONER { bits : bool , } impl ONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRIFTR { bits : bool , } impl DRIFTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PLW < '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 } } # [ doc = "Values that can be written to the field `TX_PP`" ] pub enum TX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TX_PPW :: ALL_ONE => 0 , TX_PPW :: ALL_ZERO => 1 , TX_PPW :: ZERO_ONE => 2 , TX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _TX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _TX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PLW < '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 = "Values that can be written to the field `RX_PP`" ] pub enum RX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RX_PPW :: ALL_ONE => 0 , RX_PPW :: ALL_ZERO => 1 , RX_PPW :: ZERO_ONE => 2 , RX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _RX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _RX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ONEW < 'a > { w : & 'a mut W , } impl < 'a > _ONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRIFTW < 'a > { w : & 'a mut W , } impl < 'a > _DRIFTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & self ) -> TX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TX_PLR { bits } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & self ) -> TX_PPR { TX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & self ) -> TX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TX_MPOLR { bits } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & self ) -> RX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RX_PLR { bits } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & self ) -> RX_PPR { RX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & self ) -> RX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RX_MPOLR { bits } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & self ) -> ONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONER { bits } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & self ) -> DRIFTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRIFTR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0xb001_1004 } } # [ 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 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & mut self ) -> _TX_PLW { _TX_PLW { w : self } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & mut self ) -> _TX_PPW { _TX_PPW { w : self } } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & mut self ) -> _TX_MPOLW { _TX_MPOLW { w : self } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & mut self ) -> _RX_PLW { _RX_PLW { w : self } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & mut self ) -> _RX_PPW { _RX_PPW { w : self } } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & mut self ) -> _RX_MPOLW { _RX_MPOLW { w : self } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & mut self ) -> _ONEW { _ONEW { w : self } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & mut self ) -> _DRIFTW { _DRIFTW { w : self } } } } # [ doc = "LIN Mode Register" ] pub struct LINMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Mode Register" ] pub mod linmr { # [ 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 :: LINMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `NACT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NACTR { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NACTR :: PUBLISH => 0 , NACTR :: SUBSCRIBE => 0x01 , NACTR :: IGNORE => 0x02 , NACTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NACTR { match value { 0 => NACTR :: PUBLISH , 1 => NACTR :: SUBSCRIBE , 2 => NACTR :: IGNORE , i => NACTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PUBLISH`" ] # [ inline ] pub fn is_publish ( & self ) -> bool { * self == NACTR :: PUBLISH } # [ doc = "Checks if the value of the field is `SUBSCRIBE`" ] # [ inline ] pub fn is_subscribe ( & self ) -> bool { * self == NACTR :: SUBSCRIBE } # [ doc = "Checks if the value of the field is `IGNORE`" ] # [ inline ] pub fn is_ignore ( & self ) -> bool { * self == NACTR :: IGNORE } } # [ doc = r" Value of the field" ] pub struct PARDISR { bits : bool , } impl PARDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKDISR { bits : bool , } impl CHKDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKTYPR { bits : bool , } impl CHKTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLMR { bits : bool , } impl DLMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSDISR { bits : bool , } impl FSDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WKUPTYPR { bits : bool , } impl WKUPTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLCR { bits : u8 , } impl DLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PDCMR { bits : bool , } impl PDCMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `NACT`" ] pub enum NACTW { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE } impl NACTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NACTW :: PUBLISH => 0 , NACTW :: SUBSCRIBE => 1 , NACTW :: IGNORE => 2 } } } # [ doc = r" Proxy" ] pub struct _NACTW < 'a > { w : & 'a mut W , } impl < 'a > _NACTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NACTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The USART transmits the response." ] # [ inline ] pub fn publish ( self ) -> & 'a mut W { self . variant ( NACTW :: PUBLISH ) } # [ doc = "The USART receives the response." ] # [ inline ] pub fn subscribe ( self ) -> & 'a mut W { self . variant ( NACTW :: SUBSCRIBE ) } # [ doc = "The USART does not transmit and does not receive the response." ] # [ inline ] pub fn ignore ( self ) -> & 'a mut W { self . variant ( NACTW :: IGNORE ) } # [ 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 _PARDISW < 'a > { w : & 'a mut W , } impl < 'a > _PARDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CHKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKTYPW < 'a > { w : & 'a mut W , } impl < 'a > _CHKTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLMW < 'a > { w : & 'a mut W , } impl < 'a > _DLMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSDISW < 'a > { w : & 'a mut W , } impl < 'a > _FSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WKUPTYPW < 'a > { w : & 'a mut W , } impl < 'a > _WKUPTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLCW < 'a > { w : & 'a mut W , } impl < 'a > _DLCW < '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 _PDCMW < 'a > { w : & 'a mut W , } impl < 'a > _PDCMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:1 - LIN Node Action" ] # [ inline ] pub fn nact ( & self ) -> NACTR { NACTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & self ) -> PARDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARDISR { bits } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & self ) -> CHKDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKDISR { bits } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & self ) -> CHKTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKTYPR { bits } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & self ) -> DLMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLMR { bits } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & self ) -> FSDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSDISR { bits } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & self ) -> WKUPTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WKUPTYPR { bits } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & self ) -> DLCR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DLCR { bits } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & self ) -> PDCMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PDCMR { 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 - LIN Node Action" ] # [ inline ] pub fn nact ( & mut self ) -> _NACTW { _NACTW { w : self } } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & mut self ) -> _PARDISW { _PARDISW { w : self } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & mut self ) -> _CHKDISW { _CHKDISW { w : self } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & mut self ) -> _CHKTYPW { _CHKTYPW { w : self } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & mut self ) -> _DLMW { _DLMW { w : self } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & mut self ) -> _FSDISW { _FSDISW { w : self } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & mut self ) -> _WKUPTYPW { _WKUPTYPW { w : self } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & mut self ) -> _DLCW { _DLCW { w : self } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & mut self ) -> _PDCMW { _PDCMW { w : self } } } } # [ doc = "LIN Identifier Register" ] pub struct LINIR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Identifier Register" ] pub mod linir { # [ 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 :: LINIR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IDCHRR { bits : u8 , } impl IDCHRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IDCHRW < 'a > { w : & 'a mut W , } impl < 'a > _IDCHRW < '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 - Identifier Character" ] # [ inline ] pub fn idchr ( & self ) -> IDCHRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IDCHRR { 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 - Identifier Character" ] # [ inline ] pub fn idchr ( & mut self ) -> _IDCHRW { _IDCHRW { w : self } } } } # [ doc = "LIN Baud Rate Register" ] pub struct LINBRR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Baud Rate Register" ] pub mod linbrr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LINBRR { # [ 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 LINCDR { bits : u16 , } impl LINCDR { # [ 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 LINFPR { bits : u8 , } impl LINFPR { # [ 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:15 - Clock Divider after Synchronization" ] # [ inline ] pub fn lincd ( & self ) -> LINCDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; LINCDR { bits } } # [ doc = "Bits 16:18 - Fractional Part after Synchronization" ] # [ inline ] pub fn linfp ( & self ) -> LINFPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; LINFPR { bits } } } } # [ doc = "Write Protection Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0055_5341 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5591873 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5591873 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protection Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 2" ] 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 usart2 :: RegisterBlock { 0x400a_0000 as * const _ } } impl Deref for USART2 { type Target = usart2 :: RegisterBlock ; fn deref ( & self ) -> & usart2 :: RegisterBlock { unsafe { & * USART2 :: ptr ( ) } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 2" ] pub mod usart2 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "Control Register" ] pub cr : CR_UNION , # [ doc = "Mode Register" ] pub mr : MR_UNION , # [ doc = "Interrupt Enable Register" ] pub ier : IER_UNION , # [ doc = "Interrupt Disable Register" ] pub idr : IDR_UNION , # [ doc = "Interrupt Mask Register" ] pub imr : IMR_UNION , # [ doc = "Channel Status Register" ] pub csr : CSR_UNION , # [ doc = "0x18 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x1c - Transmit Holding Register" ] pub thr : THR , # [ doc = "0x20 - Baud Rate Generator Register" ] pub brgr : BRGR , # [ doc = "0x24 - Receiver Time-out Register" ] pub rtor : RTOR , # [ doc = "0x28 - Transmitter Timeguard Register" ] pub ttgr : TTGR , _reserved11 : [ u8 ; 20usize ] , # [ doc = "0x40 - FI DI Ratio Register" ] pub fidi : FIDI , # [ doc = "0x44 - Number of Errors Register" ] pub ner : NER , _reserved13 : [ u8 ; 4usize ] , # [ doc = "0x4c - IrDA Filter Register" ] pub if_ : IF , # [ doc = "0x50 - Manchester Configuration Register" ] pub man : MAN , # [ doc = "0x54 - LIN Mode Register" ] pub linmr : LINMR , # [ doc = "0x58 - LIN Identifier Register" ] pub linir : LINIR , # [ doc = "0x5c - LIN Baud Rate Register" ] pub linbrr : LINBRR , _reserved18 : [ u8 ; 132usize ] , # [ doc = "0xe4 - Write Protection Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protection Status Register" ] pub wpsr : WPSR , _reserved20 : [ u8 ; 20usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] # [ repr ( C ) ] pub union CR_UNION { # [ doc = "0x00 - Control Register" ] pub cr_spi_mode : CR_SPI_MODE , # [ doc = "0x00 - Control Register" ] pub cr : CR , } # [ doc = "Mode Register" ] # [ repr ( C ) ] pub union MR_UNION { # [ doc = "0x04 - Mode Register" ] pub mr_spi_mode : MR_SPI_MODE , # [ doc = "0x04 - Mode Register" ] pub mr : MR , } # [ doc = "Interrupt Enable Register" ] # [ repr ( C ) ] pub union IER_UNION { # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_lin_mode : IER_LIN_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_spi_mode : IER_SPI_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier : IER , } # [ doc = "Interrupt Disable Register" ] # [ repr ( C ) ] pub union IDR_UNION { # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_lin_mode : IDR_LIN_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_spi_mode : IDR_SPI_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr : IDR , } # [ doc = "Interrupt Mask Register" ] # [ repr ( C ) ] pub union IMR_UNION { # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_lin_mode : IMR_LIN_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_spi_mode : IMR_SPI_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr : IMR , } # [ doc = "Channel Status Register" ] # [ repr ( C ) ] pub union CSR_UNION { # [ doc = "0x14 - Channel Status Register" ] pub csr_lin_mode : CSR_LIN_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr_spi_mode : CSR_SPI_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr : CSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STTBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STPBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STPBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTTOW < 'a > { w : & 'a mut W , } impl < 'a > _STTTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SENDAW < 'a > { w : & 'a mut W , } impl < 'a > _SENDAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTITW < 'a > { w : & 'a mut W , } impl < 'a > _RSTITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTNACKW < 'a > { w : & 'a mut W , } impl < 'a > _RSTNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RETTOW < 'a > { w : & 'a mut W , } impl < 'a > _RETTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSENW < 'a > { w : & 'a mut W , } impl < 'a > _RTSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSDISW < 'a > { w : & 'a mut W , } impl < 'a > _RTSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINABTW < 'a > { w : & 'a mut W , } impl < 'a > _LINABTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINWKUPW < 'a > { w : & 'a mut W , } impl < 'a > _LINWKUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 9 - Start Break" ] # [ inline ] pub fn sttbrk ( & mut self ) -> _STTBRKW { _STTBRKW { w : self } } # [ doc = "Bit 10 - Stop Break" ] # [ inline ] pub fn stpbrk ( & mut self ) -> _STPBRKW { _STPBRKW { w : self } } # [ doc = "Bit 11 - Start Time-out" ] # [ inline ] pub fn sttto ( & mut self ) -> _STTTOW { _STTTOW { w : self } } # [ doc = "Bit 12 - Send Address" ] # [ inline ] pub fn senda ( & mut self ) -> _SENDAW { _SENDAW { w : self } } # [ doc = "Bit 13 - Reset Iterations" ] # [ inline ] pub fn rstit ( & mut self ) -> _RSTITW { _RSTITW { w : self } } # [ doc = "Bit 14 - Reset Non Acknowledge" ] # [ inline ] pub fn rstnack ( & mut self ) -> _RSTNACKW { _RSTNACKW { w : self } } # [ doc = "Bit 15 - Rearm Time-out" ] # [ inline ] pub fn retto ( & mut self ) -> _RETTOW { _RETTOW { w : self } } # [ doc = "Bit 18 - Request to Send Enable" ] # [ inline ] pub fn rtsen ( & mut self ) -> _RTSENW { _RTSENW { w : self } } # [ doc = "Bit 19 - Request to Send Disable" ] # [ inline ] pub fn rtsdis ( & mut self ) -> _RTSDISW { _RTSDISW { w : self } } # [ doc = "Bit 20 - Abort LIN Transmission" ] # [ inline ] pub fn linabt ( & mut self ) -> _LINABTW { _LINABTW { w : self } } # [ doc = "Bit 21 - Send LIN Wakeup Signal" ] # [ inline ] pub fn linwkup ( & mut self ) -> _LINWKUPW { _LINWKUPW { w : self } } } } # [ doc = "Control Register" ] pub struct CR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCSW < 'a > { w : & 'a mut W , } impl < 'a > _FCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCSW < 'a > { w : & 'a mut W , } impl < 'a > _RCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 18 - Force SPI Chip Select" ] # [ inline ] pub fn fcs ( & mut self ) -> _FCSW { _FCSW { w : self } } # [ doc = "Bit 19 - Release SPI Chip Select" ] # [ inline ] pub fn rcs ( & mut self ) -> _RCSW { _RCSW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: NORMAL => 0 , USART_MODER :: RS485 => 0x01 , USART_MODER :: HW_HANDSHAKING => 0x02 , USART_MODER :: IS07816_T_0 => 0x04 , USART_MODER :: IS07816_T_1 => 0x06 , USART_MODER :: IRDA => 0x08 , USART_MODER :: LIN_MASTER => 0x0a , USART_MODER :: LIN_SLAVE => 0x0b , USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 0 => USART_MODER :: NORMAL , 1 => USART_MODER :: RS485 , 2 => USART_MODER :: HW_HANDSHAKING , 4 => USART_MODER :: IS07816_T_0 , 6 => USART_MODER :: IS07816_T_1 , 8 => USART_MODER :: IRDA , 10 => USART_MODER :: LIN_MASTER , 11 => USART_MODER :: LIN_SLAVE , 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == USART_MODER :: NORMAL } # [ doc = "Checks if the value of the field is `RS485`" ] # [ inline ] pub fn is_rs485 ( & self ) -> bool { * self == USART_MODER :: RS485 } # [ doc = "Checks if the value of the field is `HW_HANDSHAKING`" ] # [ inline ] pub fn is_hw_handshaking ( & self ) -> bool { * self == USART_MODER :: HW_HANDSHAKING } # [ doc = "Checks if the value of the field is `IS07816_T_0`" ] # [ inline ] pub fn is_is07816_t_0 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_0 } # [ doc = "Checks if the value of the field is `IS07816_T_1`" ] # [ inline ] pub fn is_is07816_t_1 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_1 } # [ doc = "Checks if the value of the field is `IRDA`" ] # [ inline ] pub fn is_irda ( & self ) -> bool { * self == USART_MODER :: IRDA } # [ doc = "Checks if the value of the field is `LIN_MASTER`" ] # [ inline ] pub fn is_lin_master ( & self ) -> bool { * self == USART_MODER :: LIN_MASTER } # [ doc = "Checks if the value of the field is `LIN_SLAVE`" ] # [ inline ] pub fn is_lin_slave ( & self ) -> bool { * self == USART_MODER :: LIN_SLAVE } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _5_BIT => 0 , CHRLR :: _6_BIT => 0x01 , CHRLR :: _7_BIT => 0x02 , CHRLR :: _8_BIT => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 0 => CHRLR :: _5_BIT , 1 => CHRLR :: _6_BIT , 2 => CHRLR :: _7_BIT , 3 => CHRLR :: _8_BIT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_5_BIT`" ] # [ inline ] pub fn is_5_bit ( & self ) -> bool { * self == CHRLR :: _5_BIT } # [ doc = "Checks if the value of the field is `_6_BIT`" ] # [ inline ] pub fn is_6_bit ( & self ) -> bool { * self == CHRLR :: _6_BIT } # [ doc = "Checks if the value of the field is `_7_BIT`" ] # [ inline ] pub fn is_7_bit ( & self ) -> bool { * self == CHRLR :: _7_BIT } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_BIT } } # [ doc = r" Value of the field" ] pub struct SYNCR { bits : bool , } impl SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PAR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PARR { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PARR :: EVEN => 0 , PARR :: ODD => 0x01 , PARR :: SPACE => 0x02 , PARR :: MARK => 0x03 , PARR :: NO => 0x04 , PARR :: MULTIDROP => 0x06 , PARR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PARR { match value { 0 => PARR :: EVEN , 1 => PARR :: ODD , 2 => PARR :: SPACE , 3 => PARR :: MARK , 4 => PARR :: NO , 6 => PARR :: MULTIDROP , i => PARR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `EVEN`" ] # [ inline ] pub fn is_even ( & self ) -> bool { * self == PARR :: EVEN } # [ doc = "Checks if the value of the field is `ODD`" ] # [ inline ] pub fn is_odd ( & self ) -> bool { * self == PARR :: ODD } # [ doc = "Checks if the value of the field is `SPACE`" ] # [ inline ] pub fn is_space ( & self ) -> bool { * self == PARR :: SPACE } # [ doc = "Checks if the value of the field is `MARK`" ] # [ inline ] pub fn is_mark ( & self ) -> bool { * self == PARR :: MARK } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == PARR :: NO } # [ doc = "Checks if the value of the field is `MULTIDROP`" ] # [ inline ] pub fn is_multidrop ( & self ) -> bool { * self == PARR :: MULTIDROP } } # [ doc = "Possible values of the field `NBSTOP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBSTOPR { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBSTOPR :: _1_BIT => 0 , NBSTOPR :: _1_5_BIT => 0x01 , NBSTOPR :: _2_BIT => 0x02 , NBSTOPR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBSTOPR { match value { 0 => NBSTOPR :: _1_BIT , 1 => NBSTOPR :: _1_5_BIT , 2 => NBSTOPR :: _2_BIT , i => NBSTOPR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1_BIT`" ] # [ inline ] pub fn is_1_bit ( & self ) -> bool { * self == NBSTOPR :: _1_BIT } # [ doc = "Checks if the value of the field is `_1_5_BIT`" ] # [ inline ] pub fn is_1_5_bit ( & self ) -> bool { * self == NBSTOPR :: _1_5_BIT } # [ doc = "Checks if the value of the field is `_2_BIT`" ] # [ inline ] pub fn is_2_bit ( & self ) -> bool { * self == NBSTOPR :: _2_BIT } } # [ doc = "Possible values of the field `CHMODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHMODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHMODER :: NORMAL => 0 , CHMODER :: AUTOMATIC => 0x01 , CHMODER :: LOCAL_LOOPBACK => 0x02 , CHMODER :: REMOTE_LOOPBACK => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHMODER { match value { 0 => CHMODER :: NORMAL , 1 => CHMODER :: AUTOMATIC , 2 => CHMODER :: LOCAL_LOOPBACK , 3 => CHMODER :: REMOTE_LOOPBACK , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == CHMODER :: NORMAL } # [ doc = "Checks if the value of the field is `AUTOMATIC`" ] # [ inline ] pub fn is_automatic ( & self ) -> bool { * self == CHMODER :: AUTOMATIC } # [ doc = "Checks if the value of the field is `LOCAL_LOOPBACK`" ] # [ inline ] pub fn is_local_loopback ( & self ) -> bool { * self == CHMODER :: LOCAL_LOOPBACK } # [ doc = "Checks if the value of the field is `REMOTE_LOOPBACK`" ] # [ inline ] pub fn is_remote_loopback ( & self ) -> bool { * self == CHMODER :: REMOTE_LOOPBACK } } # [ doc = r" Value of the field" ] pub struct MSBFR { bits : bool , } impl MSBFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODE9R { bits : bool , } impl MODE9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKOR { bits : bool , } impl CLKOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERR { bits : bool , } impl OVERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INACKR { bits : bool , } impl INACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSNACKR { bits : bool , } impl DSNACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VAR_SYNCR { bits : bool , } impl VAR_SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVDATAR { bits : bool , } impl INVDATAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MAX_ITERATIONR { bits : u8 , } impl MAX_ITERATIONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FILTERR { bits : bool , } impl FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANR { bits : bool , } impl MANR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODSYNCR { bits : bool , } impl MODSYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: NORMAL => 0 , USART_MODEW :: RS485 => 1 , USART_MODEW :: HW_HANDSHAKING => 2 , USART_MODEW :: IS07816_T_0 => 4 , USART_MODEW :: IS07816_T_1 => 6 , USART_MODEW :: IRDA => 8 , USART_MODEW :: LIN_MASTER => 10 , USART_MODEW :: LIN_SLAVE => 11 , USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: NORMAL ) } # [ doc = "RS485" ] # [ inline ] pub fn rs485 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: RS485 ) } # [ doc = "Hardware Handshaking" ] # [ inline ] pub fn hw_handshaking ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: HW_HANDSHAKING ) } # [ doc = "IS07816 Protocol: T = 0" ] # [ inline ] pub fn is07816_t_0 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_0 ) } # [ doc = "IS07816 Protocol: T = 1" ] # [ inline ] pub fn is07816_t_1 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_1 ) } # [ doc = "IrDA" ] # [ inline ] pub fn irda ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IRDA ) } # [ doc = "LIN master" ] # [ inline ] pub fn lin_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_MASTER ) } # [ doc = "LIN Slave" ] # [ inline ] pub fn lin_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_SLAVE ) } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _5_BIT => 0 , CHRLW :: _6_BIT => 1 , CHRLW :: _7_BIT => 2 , CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 5 bits" ] # [ inline ] pub fn _5_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _5_BIT ) } # [ doc = "Character length is 6 bits" ] # [ inline ] pub fn _6_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _6_BIT ) } # [ doc = "Character length is 7 bits" ] # [ inline ] pub fn _7_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _7_BIT ) } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PAR`" ] pub enum PARW { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP } impl PARW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PARW :: EVEN => 0 , PARW :: ODD => 1 , PARW :: SPACE => 2 , PARW :: MARK => 3 , PARW :: NO => 4 , PARW :: MULTIDROP => 6 } } } # [ doc = r" Proxy" ] pub struct _PARW < 'a > { w : & 'a mut W , } impl < 'a > _PARW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PARW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Even parity" ] # [ inline ] pub fn even ( self ) -> & 'a mut W { self . variant ( PARW :: EVEN ) } # [ doc = "Odd parity" ] # [ inline ] pub fn odd ( self ) -> & 'a mut W { self . variant ( PARW :: ODD ) } # [ doc = "Parity forced to 0 (Space)" ] # [ inline ] pub fn space ( self ) -> & 'a mut W { self . variant ( PARW :: SPACE ) } # [ doc = "Parity forced to 1 (Mark)" ] # [ inline ] pub fn mark ( self ) -> & 'a mut W { self . variant ( PARW :: MARK ) } # [ doc = "No parity" ] # [ inline ] pub fn no ( self ) -> & 'a mut W { self . variant ( PARW :: NO ) } # [ doc = "Multidrop mode" ] # [ inline ] pub fn multidrop ( self ) -> & 'a mut W { self . variant ( PARW :: MULTIDROP ) } # [ 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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `NBSTOP`" ] pub enum NBSTOPW { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT } impl NBSTOPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NBSTOPW :: _1_BIT => 0 , NBSTOPW :: _1_5_BIT => 1 , NBSTOPW :: _2_BIT => 2 } } } # [ doc = r" Proxy" ] pub struct _NBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _NBSTOPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NBSTOPW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 stop bit" ] # [ inline ] pub fn _1_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_BIT ) } # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] # [ inline ] pub fn _1_5_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_5_BIT ) } # [ doc = "2 stop bits" ] # [ inline ] pub fn _2_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _2_BIT ) } # [ 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 = "Values that can be written to the field `CHMODE`" ] pub enum CHMODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHMODEW :: NORMAL => 0 , CHMODEW :: AUTOMATIC => 1 , CHMODEW :: LOCAL_LOOPBACK => 2 , CHMODEW :: REMOTE_LOOPBACK => 3 } } } # [ doc = r" Proxy" ] pub struct _CHMODEW < 'a > { w : & 'a mut W , } impl < 'a > _CHMODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHMODEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( CHMODEW :: NORMAL ) } # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] # [ inline ] pub fn automatic ( self ) -> & 'a mut W { self . variant ( CHMODEW :: AUTOMATIC ) } # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] # [ inline ] pub fn local_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: LOCAL_LOOPBACK ) } # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] # [ inline ] pub fn remote_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: REMOTE_LOOPBACK ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _MSBFW < 'a > { w : & 'a mut W , } impl < 'a > _MSBFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODE9W < 'a > { w : & 'a mut W , } impl < 'a > _MODE9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CLKOW < 'a > { w : & 'a mut W , } impl < 'a > _CLKOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERW < 'a > { w : & 'a mut W , } impl < 'a > _OVERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INACKW < 'a > { w : & 'a mut W , } impl < 'a > _INACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSNACKW < 'a > { w : & 'a mut W , } impl < 'a > _DSNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VAR_SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _VAR_SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVDATAW < 'a > { w : & 'a mut W , } impl < 'a > _INVDATAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MAX_ITERATIONW < 'a > { w : & 'a mut W , } impl < 'a > _MAX_ITERATIONW < '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 _FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _FILTERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANW < 'a > { w : & 'a mut W , } impl < 'a > _MANW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODSYNCW < 'a > { w : & 'a mut W , } impl < 'a > _MODSYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 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:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & self ) -> SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNCR { bits } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & self ) -> PARR { PARR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & self ) -> NBSTOPR { NBSTOPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & self ) -> CHMODER { CHMODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & self ) -> MSBFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSBFR { bits } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & self ) -> MODE9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODE9R { bits } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & self ) -> CLKOR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKOR { bits } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & self ) -> OVERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERR { bits } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & self ) -> INACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INACKR { bits } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & self ) -> DSNACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSNACKR { bits } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & self ) -> VAR_SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VAR_SYNCR { bits } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & self ) -> INVDATAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVDATAR { bits } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & self ) -> MAX_ITERATIONR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MAX_ITERATIONR { bits } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & self ) -> FILTERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FILTERR { bits } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & self ) -> MANR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANR { bits } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & self ) -> MODSYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODSYNCR { bits } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & self ) -> ONEBITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONEBITR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & mut self ) -> _SYNCW { _SYNCW { w : self } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & mut self ) -> _PARW { _PARW { w : self } } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & mut self ) -> _NBSTOPW { _NBSTOPW { w : self } } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & mut self ) -> _CHMODEW { _CHMODEW { w : self } } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & mut self ) -> _MSBFW { _MSBFW { w : self } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & mut self ) -> _MODE9W { _MODE9W { w : self } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & mut self ) -> _CLKOW { _CLKOW { w : self } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & mut self ) -> _OVERW { _OVERW { w : self } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & mut self ) -> _INACKW { _INACKW { w : self } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & mut self ) -> _DSNACKW { _DSNACKW { w : self } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & mut self ) -> _VAR_SYNCW { _VAR_SYNCW { w : self } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & mut self ) -> _INVDATAW { _INVDATAW { w : self } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & mut self ) -> _MAX_ITERATIONW { _MAX_ITERATIONW { w : self } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & mut self ) -> _FILTERW { _FILTERW { w : self } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & mut self ) -> _MANW { _MANW { w : self } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & mut self ) -> _MODSYNCW { _MODSYNCW { w : self } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & mut self ) -> _ONEBITW { _ONEBITW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr_spi_mode { # [ 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 :: MR_SPI_MODE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 8 bits" ] _8_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _8_BIT => 0x03 , CHRLR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 3 => CHRLR :: _8_BIT , i => CHRLR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_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 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 WRDBTR { bits : bool , } impl WRDBTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ 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 _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 = 8 ; 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _WRDBTW < 'a > { w : & 'a mut W , } impl < 'a > _WRDBTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & self ) -> CPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPHAR { bits } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & self ) -> WRDBTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WRDBTR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & mut self ) -> _CPHAW { _CPHAW { w : self } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & mut self ) -> _WRDBTW { _WRDBTW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Enable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max number of Repetitions Reached Interrupt Enable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Enable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Enable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Enable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Enable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Enable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Enable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Enable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Enable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Enable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Enable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Enable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Enable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Disable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Disable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Disable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Disable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Disable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Disable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Disable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Disable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Disable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Disable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Disable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Disable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Disable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Disable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANER { bits : bool , } impl MANER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Receiver Break Interrupt Mask" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmit Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Mask" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Buffer Empty Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Buffer Full Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Mask" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Mask" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 24 - Manchester Error Interrupt Mask" ] # [ inline ] pub fn mane ( & self ) -> MANER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANER { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Mask" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Mask" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Mask" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Mask" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Mask" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Mask" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Mask" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Mask" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Mask" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 MANERRR { bits : bool , } impl MANERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Break Received/End of Break" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receiver Transfer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmitter Transfer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Transmission Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Reception Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Flag" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 23 - Image of CTS Input" ] # [ inline ] pub fn cts ( & self ) -> CTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSR { bits } } # [ doc = "Bit 24 - Manchester Error" ] # [ inline ] pub fn manerr ( & self ) -> MANERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANERRR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Underrun Error" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBLSR { bits : bool , } impl LINBLSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 23 - LIN Bus Line Status" ] # [ inline ] pub fn linbls ( & self ) -> LINBLSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBLSR { bits } } # [ doc = "Bit 25 - LIN Bit Error" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Error" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 RXCHRR { bits : u16 , } impl RXCHRR { # [ 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 RXSYNHR { bits : bool , } impl RXSYNHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:8 - Received Character" ] # [ inline ] pub fn rxchr ( & self ) -> RXCHRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCHRR { bits } } # [ doc = "Bit 15 - Received Sync" ] # [ inline ] pub fn rxsynh ( & self ) -> RXSYNHR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSYNHR { bits } } } } # [ doc = "Transmit Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCHRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCHRW < '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 } } # [ doc = r" Proxy" ] pub struct _TXSYNHW < 'a > { w : & 'a mut W , } impl < 'a > _TXSYNHW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:8 - Character to be Transmitted" ] # [ inline ] pub fn txchr ( & mut self ) -> _TXCHRW { _TXCHRW { w : self } } # [ doc = "Bit 15 - Sync Field to be Transmitted" ] # [ inline ] pub fn txsynh ( & mut self ) -> _TXSYNHW { _TXSYNHW { w : self } } } } # [ doc = "Baud Rate Generator Register" ] pub struct BRGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Baud Rate Generator Register" ] pub mod brgr { # [ 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 :: BRGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDR { bits : u16 , } impl CDR { # [ 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 FPR { bits : u8 , } impl FPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDW < 'a > { w : & 'a mut W , } impl < 'a > _CDW < '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 } } # [ doc = r" Proxy" ] pub struct _FPW < 'a > { w : & 'a mut W , } impl < 'a > _FPW < '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 = 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:15 - Clock Divider" ] # [ inline ] pub fn cd ( & self ) -> CDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; CDR { bits } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & self ) -> FPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPR { 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 - Clock Divider" ] # [ inline ] pub fn cd ( & mut self ) -> _CDW { _CDW { w : self } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & mut self ) -> _FPW { _FPW { w : self } } } } # [ doc = "Receiver Time-out Register" ] pub struct RTOR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receiver Time-out 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 < F > ( & 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 < F > ( & 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 TOR { bits : u32 , } impl TOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TOW < 'a > { w : & 'a mut W , } impl < 'a > _TOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0001_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:16 - Time-out Value" ] # [ inline ] pub fn to ( & self ) -> TOR { let bits = { const MASK : u32 = 0x0001_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TOR { 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:16 - Time-out Value" ] # [ inline ] pub fn to ( & mut self ) -> _TOW { _TOW { w : self } } } } # [ doc = "Transmitter Timeguard Register" ] pub struct TTGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmitter Timeguard Register" ] pub mod ttgr { # [ 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 :: TTGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TGR { bits : u8 , } impl TGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _TGW < 'a > { w : & 'a mut W , } impl < 'a > _TGW < '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 - Timeguard Value" ] # [ inline ] pub fn tg ( & self ) -> TGR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TGR { 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 - Timeguard Value" ] # [ inline ] pub fn tg ( & mut self ) -> _TGW { _TGW { w : self } } } } # [ doc = "FI DI Ratio Register" ] pub struct FIDI { register : :: vcell :: VolatileCell < u32 > } # [ doc = "FI DI Ratio Register" ] pub mod fidi { # [ 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 :: FIDI { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FI_DI_RATIOR { bits : u16 , } impl FI_DI_RATIOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _FI_DI_RATIOW < 'a > { w : & 'a mut W , } impl < 'a > _FI_DI_RATIOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & self ) -> FI_DI_RATIOR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; FI_DI_RATIOR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0174 } } # [ 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & mut self ) -> _FI_DI_RATIOW { _FI_DI_RATIOW { w : self } } } } # [ doc = "Number of Errors Register" ] pub struct NER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Number of Errors Register" ] pub mod ner { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: NER { # [ 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 NB_ERRORSR { bits : u8 , } impl NB_ERRORSR { # [ 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 - Number of Errors" ] # [ inline ] pub fn nb_errors ( & self ) -> NB_ERRORSR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NB_ERRORSR { bits } } } } # [ doc = "IrDA Filter Register" ] pub struct IF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "IrDA Filter Register" ] pub mod if_ { # [ 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 :: IF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IRDA_FILTERR { bits : u8 , } impl IRDA_FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IRDA_FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _IRDA_FILTERW < '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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & self ) -> IRDA_FILTERR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IRDA_FILTERR { 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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & mut self ) -> _IRDA_FILTERW { _IRDA_FILTERW { w : self } } } } # [ doc = "Manchester Configuration Register" ] pub struct MAN { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Manchester Configuration Register" ] pub mod man { # [ 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 :: MAN { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TX_PLR { bits : u8 , } impl TX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `TX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TX_PPR :: ALL_ONE => 0 , TX_PPR :: ALL_ZERO => 0x01 , TX_PPR :: ZERO_ONE => 0x02 , TX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TX_PPR { match value { 0 => TX_PPR :: ALL_ONE , 1 => TX_PPR :: ALL_ZERO , 2 => TX_PPR :: ZERO_ONE , 3 => TX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == TX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == TX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == TX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == TX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct TX_MPOLR { bits : bool , } impl TX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RX_PLR { bits : u8 , } impl RX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `RX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RX_PPR :: ALL_ONE => 0 , RX_PPR :: ALL_ZERO => 0x01 , RX_PPR :: ZERO_ONE => 0x02 , RX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RX_PPR { match value { 0 => RX_PPR :: ALL_ONE , 1 => RX_PPR :: ALL_ZERO , 2 => RX_PPR :: ZERO_ONE , 3 => RX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == RX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == RX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == RX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == RX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct RX_MPOLR { bits : bool , } impl RX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ONER { bits : bool , } impl ONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRIFTR { bits : bool , } impl DRIFTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PLW < '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 } } # [ doc = "Values that can be written to the field `TX_PP`" ] pub enum TX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TX_PPW :: ALL_ONE => 0 , TX_PPW :: ALL_ZERO => 1 , TX_PPW :: ZERO_ONE => 2 , TX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _TX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _TX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PLW < '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 = "Values that can be written to the field `RX_PP`" ] pub enum RX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RX_PPW :: ALL_ONE => 0 , RX_PPW :: ALL_ZERO => 1 , RX_PPW :: ZERO_ONE => 2 , RX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _RX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _RX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ONEW < 'a > { w : & 'a mut W , } impl < 'a > _ONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRIFTW < 'a > { w : & 'a mut W , } impl < 'a > _DRIFTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & self ) -> TX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TX_PLR { bits } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & self ) -> TX_PPR { TX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & self ) -> TX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TX_MPOLR { bits } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & self ) -> RX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RX_PLR { bits } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & self ) -> RX_PPR { RX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & self ) -> RX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RX_MPOLR { bits } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & self ) -> ONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONER { bits } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & self ) -> DRIFTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRIFTR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0xb001_1004 } } # [ 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 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & mut self ) -> _TX_PLW { _TX_PLW { w : self } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & mut self ) -> _TX_PPW { _TX_PPW { w : self } } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & mut self ) -> _TX_MPOLW { _TX_MPOLW { w : self } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & mut self ) -> _RX_PLW { _RX_PLW { w : self } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & mut self ) -> _RX_PPW { _RX_PPW { w : self } } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & mut self ) -> _RX_MPOLW { _RX_MPOLW { w : self } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & mut self ) -> _ONEW { _ONEW { w : self } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & mut self ) -> _DRIFTW { _DRIFTW { w : self } } } } # [ doc = "LIN Mode Register" ] pub struct LINMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Mode Register" ] pub mod linmr { # [ 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 :: LINMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `NACT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NACTR { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NACTR :: PUBLISH => 0 , NACTR :: SUBSCRIBE => 0x01 , NACTR :: IGNORE => 0x02 , NACTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NACTR { match value { 0 => NACTR :: PUBLISH , 1 => NACTR :: SUBSCRIBE , 2 => NACTR :: IGNORE , i => NACTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PUBLISH`" ] # [ inline ] pub fn is_publish ( & self ) -> bool { * self == NACTR :: PUBLISH } # [ doc = "Checks if the value of the field is `SUBSCRIBE`" ] # [ inline ] pub fn is_subscribe ( & self ) -> bool { * self == NACTR :: SUBSCRIBE } # [ doc = "Checks if the value of the field is `IGNORE`" ] # [ inline ] pub fn is_ignore ( & self ) -> bool { * self == NACTR :: IGNORE } } # [ doc = r" Value of the field" ] pub struct PARDISR { bits : bool , } impl PARDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKDISR { bits : bool , } impl CHKDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKTYPR { bits : bool , } impl CHKTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLMR { bits : bool , } impl DLMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSDISR { bits : bool , } impl FSDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WKUPTYPR { bits : bool , } impl WKUPTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLCR { bits : u8 , } impl DLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PDCMR { bits : bool , } impl PDCMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `NACT`" ] pub enum NACTW { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE } impl NACTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NACTW :: PUBLISH => 0 , NACTW :: SUBSCRIBE => 1 , NACTW :: IGNORE => 2 } } } # [ doc = r" Proxy" ] pub struct _NACTW < 'a > { w : & 'a mut W , } impl < 'a > _NACTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NACTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The USART transmits the response." ] # [ inline ] pub fn publish ( self ) -> & 'a mut W { self . variant ( NACTW :: PUBLISH ) } # [ doc = "The USART receives the response." ] # [ inline ] pub fn subscribe ( self ) -> & 'a mut W { self . variant ( NACTW :: SUBSCRIBE ) } # [ doc = "The USART does not transmit and does not receive the response." ] # [ inline ] pub fn ignore ( self ) -> & 'a mut W { self . variant ( NACTW :: IGNORE ) } # [ 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 _PARDISW < 'a > { w : & 'a mut W , } impl < 'a > _PARDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CHKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKTYPW < 'a > { w : & 'a mut W , } impl < 'a > _CHKTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLMW < 'a > { w : & 'a mut W , } impl < 'a > _DLMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSDISW < 'a > { w : & 'a mut W , } impl < 'a > _FSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WKUPTYPW < 'a > { w : & 'a mut W , } impl < 'a > _WKUPTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLCW < 'a > { w : & 'a mut W , } impl < 'a > _DLCW < '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 _PDCMW < 'a > { w : & 'a mut W , } impl < 'a > _PDCMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:1 - LIN Node Action" ] # [ inline ] pub fn nact ( & self ) -> NACTR { NACTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & self ) -> PARDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARDISR { bits } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & self ) -> CHKDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKDISR { bits } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & self ) -> CHKTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKTYPR { bits } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & self ) -> DLMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLMR { bits } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & self ) -> FSDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSDISR { bits } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & self ) -> WKUPTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WKUPTYPR { bits } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & self ) -> DLCR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DLCR { bits } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & self ) -> PDCMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PDCMR { 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 - LIN Node Action" ] # [ inline ] pub fn nact ( & mut self ) -> _NACTW { _NACTW { w : self } } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & mut self ) -> _PARDISW { _PARDISW { w : self } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & mut self ) -> _CHKDISW { _CHKDISW { w : self } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & mut self ) -> _CHKTYPW { _CHKTYPW { w : self } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & mut self ) -> _DLMW { _DLMW { w : self } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & mut self ) -> _FSDISW { _FSDISW { w : self } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & mut self ) -> _WKUPTYPW { _WKUPTYPW { w : self } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & mut self ) -> _DLCW { _DLCW { w : self } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & mut self ) -> _PDCMW { _PDCMW { w : self } } } } # [ doc = "LIN Identifier Register" ] pub struct LINIR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Identifier Register" ] pub mod linir { # [ 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 :: LINIR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IDCHRR { bits : u8 , } impl IDCHRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IDCHRW < 'a > { w : & 'a mut W , } impl < 'a > _IDCHRW < '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 - Identifier Character" ] # [ inline ] pub fn idchr ( & self ) -> IDCHRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IDCHRR { 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 - Identifier Character" ] # [ inline ] pub fn idchr ( & mut self ) -> _IDCHRW { _IDCHRW { w : self } } } } # [ doc = "LIN Baud Rate Register" ] pub struct LINBRR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Baud Rate Register" ] pub mod linbrr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LINBRR { # [ 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 LINCDR { bits : u16 , } impl LINCDR { # [ 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 LINFPR { bits : u8 , } impl LINFPR { # [ 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:15 - Clock Divider after Synchronization" ] # [ inline ] pub fn lincd ( & self ) -> LINCDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; LINCDR { bits } } # [ doc = "Bits 16:18 - Fractional Part after Synchronization" ] # [ inline ] pub fn linfp ( & self ) -> LINFPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; LINFPR { bits } } } } # [ doc = "Write Protection Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0055_5341 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5591873 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5591873 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protection Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 3" ] pub struct USART3 { _marker : PhantomData < * const ( ) > } unsafe impl Send for USART3 { } impl USART3 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const usart3 :: RegisterBlock { 0x400a_4000 as * const _ } } impl Deref for USART3 { type Target = usart3 :: RegisterBlock ; fn deref ( & self ) -> & usart3 :: RegisterBlock { unsafe { & * USART3 :: ptr ( ) } } } # [ doc = "Universal Synchronous Asynchronous Receiver Transmitter 3" ] pub mod usart3 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "Control Register" ] pub cr : CR_UNION , # [ doc = "Mode Register" ] pub mr : MR_UNION , # [ doc = "Interrupt Enable Register" ] pub ier : IER_UNION , # [ doc = "Interrupt Disable Register" ] pub idr : IDR_UNION , # [ doc = "Interrupt Mask Register" ] pub imr : IMR_UNION , # [ doc = "Channel Status Register" ] pub csr : CSR_UNION , # [ doc = "0x18 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x1c - Transmit Holding Register" ] pub thr : THR , # [ doc = "0x20 - Baud Rate Generator Register" ] pub brgr : BRGR , # [ doc = "0x24 - Receiver Time-out Register" ] pub rtor : RTOR , # [ doc = "0x28 - Transmitter Timeguard Register" ] pub ttgr : TTGR , _reserved11 : [ u8 ; 20usize ] , # [ doc = "0x40 - FI DI Ratio Register" ] pub fidi : FIDI , # [ doc = "0x44 - Number of Errors Register" ] pub ner : NER , _reserved13 : [ u8 ; 4usize ] , # [ doc = "0x4c - IrDA Filter Register" ] pub if_ : IF , # [ doc = "0x50 - Manchester Configuration Register" ] pub man : MAN , # [ doc = "0x54 - LIN Mode Register" ] pub linmr : LINMR , # [ doc = "0x58 - LIN Identifier Register" ] pub linir : LINIR , # [ doc = "0x5c - LIN Baud Rate Register" ] pub linbrr : LINBRR , _reserved18 : [ u8 ; 132usize ] , # [ doc = "0xe4 - Write Protection Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protection Status Register" ] pub wpsr : WPSR , _reserved20 : [ u8 ; 20usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] # [ repr ( C ) ] pub union CR_UNION { # [ doc = "0x00 - Control Register" ] pub cr_spi_mode : CR_SPI_MODE , # [ doc = "0x00 - Control Register" ] pub cr : CR , } # [ doc = "Mode Register" ] # [ repr ( C ) ] pub union MR_UNION { # [ doc = "0x04 - Mode Register" ] pub mr_spi_mode : MR_SPI_MODE , # [ doc = "0x04 - Mode Register" ] pub mr : MR , } # [ doc = "Interrupt Enable Register" ] # [ repr ( C ) ] pub union IER_UNION { # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_lin_mode : IER_LIN_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier_spi_mode : IER_SPI_MODE , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier : IER , } # [ doc = "Interrupt Disable Register" ] # [ repr ( C ) ] pub union IDR_UNION { # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_lin_mode : IDR_LIN_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr_spi_mode : IDR_SPI_MODE , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr : IDR , } # [ doc = "Interrupt Mask Register" ] # [ repr ( C ) ] pub union IMR_UNION { # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_lin_mode : IMR_LIN_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr_spi_mode : IMR_SPI_MODE , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr : IMR , } # [ doc = "Channel Status Register" ] # [ repr ( C ) ] pub union CSR_UNION { # [ doc = "0x14 - Channel Status Register" ] pub csr_lin_mode : CSR_LIN_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr_spi_mode : CSR_SPI_MODE , # [ doc = "0x14 - Channel Status Register" ] pub csr : CSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STTBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STPBRKW < 'a > { w : & 'a mut W , } impl < 'a > _STPBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STTTOW < 'a > { w : & 'a mut W , } impl < 'a > _STTTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SENDAW < 'a > { w : & 'a mut W , } impl < 'a > _SENDAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTITW < 'a > { w : & 'a mut W , } impl < 'a > _RSTITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTNACKW < 'a > { w : & 'a mut W , } impl < 'a > _RSTNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RETTOW < 'a > { w : & 'a mut W , } impl < 'a > _RETTOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSENW < 'a > { w : & 'a mut W , } impl < 'a > _RTSENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTSDISW < 'a > { w : & 'a mut W , } impl < 'a > _RTSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINABTW < 'a > { w : & 'a mut W , } impl < 'a > _LINABTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINWKUPW < 'a > { w : & 'a mut W , } impl < 'a > _LINWKUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 9 - Start Break" ] # [ inline ] pub fn sttbrk ( & mut self ) -> _STTBRKW { _STTBRKW { w : self } } # [ doc = "Bit 10 - Stop Break" ] # [ inline ] pub fn stpbrk ( & mut self ) -> _STPBRKW { _STPBRKW { w : self } } # [ doc = "Bit 11 - Start Time-out" ] # [ inline ] pub fn sttto ( & mut self ) -> _STTTOW { _STTTOW { w : self } } # [ doc = "Bit 12 - Send Address" ] # [ inline ] pub fn senda ( & mut self ) -> _SENDAW { _SENDAW { w : self } } # [ doc = "Bit 13 - Reset Iterations" ] # [ inline ] pub fn rstit ( & mut self ) -> _RSTITW { _RSTITW { w : self } } # [ doc = "Bit 14 - Reset Non Acknowledge" ] # [ inline ] pub fn rstnack ( & mut self ) -> _RSTNACKW { _RSTNACKW { w : self } } # [ doc = "Bit 15 - Rearm Time-out" ] # [ inline ] pub fn retto ( & mut self ) -> _RETTOW { _RETTOW { w : self } } # [ doc = "Bit 18 - Request to Send Enable" ] # [ inline ] pub fn rtsen ( & mut self ) -> _RTSENW { _RTSENW { w : self } } # [ doc = "Bit 19 - Request to Send Disable" ] # [ inline ] pub fn rtsdis ( & mut self ) -> _RTSDISW { _RTSDISW { w : self } } # [ doc = "Bit 20 - Abort LIN Transmission" ] # [ inline ] pub fn linabt ( & mut self ) -> _LINABTW { _LINABTW { w : self } } # [ doc = "Bit 21 - Send LIN Wakeup Signal" ] # [ inline ] pub fn linwkup ( & mut self ) -> _LINWKUPW { _LINWKUPW { w : self } } } } # [ doc = "Control Register" ] pub struct CR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FCSW < 'a > { w : & 'a mut W , } impl < 'a > _FCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCSW < 'a > { w : & 'a mut W , } impl < 'a > _RCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } # [ doc = "Bit 18 - Force SPI Chip Select" ] # [ inline ] pub fn fcs ( & mut self ) -> _FCSW { _FCSW { w : self } } # [ doc = "Bit 19 - Release SPI Chip Select" ] # [ inline ] pub fn rcs ( & mut self ) -> _RCSW { _RCSW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: NORMAL => 0 , USART_MODER :: RS485 => 0x01 , USART_MODER :: HW_HANDSHAKING => 0x02 , USART_MODER :: IS07816_T_0 => 0x04 , USART_MODER :: IS07816_T_1 => 0x06 , USART_MODER :: IRDA => 0x08 , USART_MODER :: LIN_MASTER => 0x0a , USART_MODER :: LIN_SLAVE => 0x0b , USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 0 => USART_MODER :: NORMAL , 1 => USART_MODER :: RS485 , 2 => USART_MODER :: HW_HANDSHAKING , 4 => USART_MODER :: IS07816_T_0 , 6 => USART_MODER :: IS07816_T_1 , 8 => USART_MODER :: IRDA , 10 => USART_MODER :: LIN_MASTER , 11 => USART_MODER :: LIN_SLAVE , 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == USART_MODER :: NORMAL } # [ doc = "Checks if the value of the field is `RS485`" ] # [ inline ] pub fn is_rs485 ( & self ) -> bool { * self == USART_MODER :: RS485 } # [ doc = "Checks if the value of the field is `HW_HANDSHAKING`" ] # [ inline ] pub fn is_hw_handshaking ( & self ) -> bool { * self == USART_MODER :: HW_HANDSHAKING } # [ doc = "Checks if the value of the field is `IS07816_T_0`" ] # [ inline ] pub fn is_is07816_t_0 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_0 } # [ doc = "Checks if the value of the field is `IS07816_T_1`" ] # [ inline ] pub fn is_is07816_t_1 ( & self ) -> bool { * self == USART_MODER :: IS07816_T_1 } # [ doc = "Checks if the value of the field is `IRDA`" ] # [ inline ] pub fn is_irda ( & self ) -> bool { * self == USART_MODER :: IRDA } # [ doc = "Checks if the value of the field is `LIN_MASTER`" ] # [ inline ] pub fn is_lin_master ( & self ) -> bool { * self == USART_MODER :: LIN_MASTER } # [ doc = "Checks if the value of the field is `LIN_SLAVE`" ] # [ inline ] pub fn is_lin_slave ( & self ) -> bool { * self == USART_MODER :: LIN_SLAVE } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _5_BIT => 0 , CHRLR :: _6_BIT => 0x01 , CHRLR :: _7_BIT => 0x02 , CHRLR :: _8_BIT => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 0 => CHRLR :: _5_BIT , 1 => CHRLR :: _6_BIT , 2 => CHRLR :: _7_BIT , 3 => CHRLR :: _8_BIT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_5_BIT`" ] # [ inline ] pub fn is_5_bit ( & self ) -> bool { * self == CHRLR :: _5_BIT } # [ doc = "Checks if the value of the field is `_6_BIT`" ] # [ inline ] pub fn is_6_bit ( & self ) -> bool { * self == CHRLR :: _6_BIT } # [ doc = "Checks if the value of the field is `_7_BIT`" ] # [ inline ] pub fn is_7_bit ( & self ) -> bool { * self == CHRLR :: _7_BIT } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_BIT } } # [ doc = r" Value of the field" ] pub struct SYNCR { bits : bool , } impl SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PAR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PARR { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PARR :: EVEN => 0 , PARR :: ODD => 0x01 , PARR :: SPACE => 0x02 , PARR :: MARK => 0x03 , PARR :: NO => 0x04 , PARR :: MULTIDROP => 0x06 , PARR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PARR { match value { 0 => PARR :: EVEN , 1 => PARR :: ODD , 2 => PARR :: SPACE , 3 => PARR :: MARK , 4 => PARR :: NO , 6 => PARR :: MULTIDROP , i => PARR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `EVEN`" ] # [ inline ] pub fn is_even ( & self ) -> bool { * self == PARR :: EVEN } # [ doc = "Checks if the value of the field is `ODD`" ] # [ inline ] pub fn is_odd ( & self ) -> bool { * self == PARR :: ODD } # [ doc = "Checks if the value of the field is `SPACE`" ] # [ inline ] pub fn is_space ( & self ) -> bool { * self == PARR :: SPACE } # [ doc = "Checks if the value of the field is `MARK`" ] # [ inline ] pub fn is_mark ( & self ) -> bool { * self == PARR :: MARK } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == PARR :: NO } # [ doc = "Checks if the value of the field is `MULTIDROP`" ] # [ inline ] pub fn is_multidrop ( & self ) -> bool { * self == PARR :: MULTIDROP } } # [ doc = "Possible values of the field `NBSTOP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBSTOPR { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NBSTOPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBSTOPR :: _1_BIT => 0 , NBSTOPR :: _1_5_BIT => 0x01 , NBSTOPR :: _2_BIT => 0x02 , NBSTOPR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBSTOPR { match value { 0 => NBSTOPR :: _1_BIT , 1 => NBSTOPR :: _1_5_BIT , 2 => NBSTOPR :: _2_BIT , i => NBSTOPR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1_BIT`" ] # [ inline ] pub fn is_1_bit ( & self ) -> bool { * self == NBSTOPR :: _1_BIT } # [ doc = "Checks if the value of the field is `_1_5_BIT`" ] # [ inline ] pub fn is_1_5_bit ( & self ) -> bool { * self == NBSTOPR :: _1_5_BIT } # [ doc = "Checks if the value of the field is `_2_BIT`" ] # [ inline ] pub fn is_2_bit ( & self ) -> bool { * self == NBSTOPR :: _2_BIT } } # [ doc = "Possible values of the field `CHMODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHMODER { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHMODER :: NORMAL => 0 , CHMODER :: AUTOMATIC => 0x01 , CHMODER :: LOCAL_LOOPBACK => 0x02 , CHMODER :: REMOTE_LOOPBACK => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHMODER { match value { 0 => CHMODER :: NORMAL , 1 => CHMODER :: AUTOMATIC , 2 => CHMODER :: LOCAL_LOOPBACK , 3 => CHMODER :: REMOTE_LOOPBACK , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == CHMODER :: NORMAL } # [ doc = "Checks if the value of the field is `AUTOMATIC`" ] # [ inline ] pub fn is_automatic ( & self ) -> bool { * self == CHMODER :: AUTOMATIC } # [ doc = "Checks if the value of the field is `LOCAL_LOOPBACK`" ] # [ inline ] pub fn is_local_loopback ( & self ) -> bool { * self == CHMODER :: LOCAL_LOOPBACK } # [ doc = "Checks if the value of the field is `REMOTE_LOOPBACK`" ] # [ inline ] pub fn is_remote_loopback ( & self ) -> bool { * self == CHMODER :: REMOTE_LOOPBACK } } # [ doc = r" Value of the field" ] pub struct MSBFR { bits : bool , } impl MSBFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODE9R { bits : bool , } impl MODE9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLKOR { bits : bool , } impl CLKOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERR { bits : bool , } impl OVERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INACKR { bits : bool , } impl INACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSNACKR { bits : bool , } impl DSNACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VAR_SYNCR { bits : bool , } impl VAR_SYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INVDATAR { bits : bool , } impl INVDATAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MAX_ITERATIONR { bits : u8 , } impl MAX_ITERATIONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FILTERR { bits : bool , } impl FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANR { bits : bool , } impl MANR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MODSYNCR { bits : bool , } impl MODSYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "RS485" ] RS485 , # [ doc = "Hardware Handshaking" ] HW_HANDSHAKING , # [ doc = "IS07816 Protocol: T = 0" ] IS07816_T_0 , # [ doc = "IS07816 Protocol: T = 1" ] IS07816_T_1 , # [ doc = "IrDA" ] IRDA , # [ doc = "LIN master" ] LIN_MASTER , # [ doc = "LIN Slave" ] LIN_SLAVE , # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: NORMAL => 0 , USART_MODEW :: RS485 => 1 , USART_MODEW :: HW_HANDSHAKING => 2 , USART_MODEW :: IS07816_T_0 => 4 , USART_MODEW :: IS07816_T_1 => 6 , USART_MODEW :: IRDA => 8 , USART_MODEW :: LIN_MASTER => 10 , USART_MODEW :: LIN_SLAVE => 11 , USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: NORMAL ) } # [ doc = "RS485" ] # [ inline ] pub fn rs485 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: RS485 ) } # [ doc = "Hardware Handshaking" ] # [ inline ] pub fn hw_handshaking ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: HW_HANDSHAKING ) } # [ doc = "IS07816 Protocol: T = 0" ] # [ inline ] pub fn is07816_t_0 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_0 ) } # [ doc = "IS07816 Protocol: T = 1" ] # [ inline ] pub fn is07816_t_1 ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IS07816_T_1 ) } # [ doc = "IrDA" ] # [ inline ] pub fn irda ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: IRDA ) } # [ doc = "LIN master" ] # [ inline ] pub fn lin_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_MASTER ) } # [ doc = "LIN Slave" ] # [ inline ] pub fn lin_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: LIN_SLAVE ) } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 5 bits" ] _5_BIT , # [ doc = "Character length is 6 bits" ] _6_BIT , # [ doc = "Character length is 7 bits" ] _7_BIT , # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _5_BIT => 0 , CHRLW :: _6_BIT => 1 , CHRLW :: _7_BIT => 2 , CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 5 bits" ] # [ inline ] pub fn _5_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _5_BIT ) } # [ doc = "Character length is 6 bits" ] # [ inline ] pub fn _6_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _6_BIT ) } # [ doc = "Character length is 7 bits" ] # [ inline ] pub fn _7_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _7_BIT ) } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PAR`" ] pub enum PARW { # [ doc = "Even parity" ] EVEN , # [ doc = "Odd parity" ] ODD , # [ doc = "Parity forced to 0 (Space)" ] SPACE , # [ doc = "Parity forced to 1 (Mark)" ] MARK , # [ doc = "No parity" ] NO , # [ doc = "Multidrop mode" ] MULTIDROP } impl PARW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PARW :: EVEN => 0 , PARW :: ODD => 1 , PARW :: SPACE => 2 , PARW :: MARK => 3 , PARW :: NO => 4 , PARW :: MULTIDROP => 6 } } } # [ doc = r" Proxy" ] pub struct _PARW < 'a > { w : & 'a mut W , } impl < 'a > _PARW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PARW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Even parity" ] # [ inline ] pub fn even ( self ) -> & 'a mut W { self . variant ( PARW :: EVEN ) } # [ doc = "Odd parity" ] # [ inline ] pub fn odd ( self ) -> & 'a mut W { self . variant ( PARW :: ODD ) } # [ doc = "Parity forced to 0 (Space)" ] # [ inline ] pub fn space ( self ) -> & 'a mut W { self . variant ( PARW :: SPACE ) } # [ doc = "Parity forced to 1 (Mark)" ] # [ inline ] pub fn mark ( self ) -> & 'a mut W { self . variant ( PARW :: MARK ) } # [ doc = "No parity" ] # [ inline ] pub fn no ( self ) -> & 'a mut W { self . variant ( PARW :: NO ) } # [ doc = "Multidrop mode" ] # [ inline ] pub fn multidrop ( self ) -> & 'a mut W { self . variant ( PARW :: MULTIDROP ) } # [ 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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `NBSTOP`" ] pub enum NBSTOPW { # [ doc = "1 stop bit" ] _1_BIT , # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] _1_5_BIT , # [ doc = "2 stop bits" ] _2_BIT } impl NBSTOPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NBSTOPW :: _1_BIT => 0 , NBSTOPW :: _1_5_BIT => 1 , NBSTOPW :: _2_BIT => 2 } } } # [ doc = r" Proxy" ] pub struct _NBSTOPW < 'a > { w : & 'a mut W , } impl < 'a > _NBSTOPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NBSTOPW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 stop bit" ] # [ inline ] pub fn _1_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_BIT ) } # [ doc = "1.5 stop bit (SYNC = 0) or reserved (SYNC = 1)" ] # [ inline ] pub fn _1_5_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _1_5_BIT ) } # [ doc = "2 stop bits" ] # [ inline ] pub fn _2_bit ( self ) -> & 'a mut W { self . variant ( NBSTOPW :: _2_BIT ) } # [ 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 = "Values that can be written to the field `CHMODE`" ] pub enum CHMODEW { # [ doc = "Normal mode" ] NORMAL , # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] AUTOMATIC , # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] REMOTE_LOOPBACK } impl CHMODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHMODEW :: NORMAL => 0 , CHMODEW :: AUTOMATIC => 1 , CHMODEW :: LOCAL_LOOPBACK => 2 , CHMODEW :: REMOTE_LOOPBACK => 3 } } } # [ doc = r" Proxy" ] pub struct _CHMODEW < 'a > { w : & 'a mut W , } impl < 'a > _CHMODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHMODEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( CHMODEW :: NORMAL ) } # [ doc = "Automatic Echo. Receiver input is connected to the TXD pin." ] # [ inline ] pub fn automatic ( self ) -> & 'a mut W { self . variant ( CHMODEW :: AUTOMATIC ) } # [ doc = "Local Loopback. Transmitter output is connected to the Receiver Input." ] # [ inline ] pub fn local_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: LOCAL_LOOPBACK ) } # [ doc = "Remote Loopback. RXD pin is internally connected to the TXD pin." ] # [ inline ] pub fn remote_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: REMOTE_LOOPBACK ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _MSBFW < 'a > { w : & 'a mut W , } impl < 'a > _MSBFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODE9W < 'a > { w : & 'a mut W , } impl < 'a > _MODE9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CLKOW < 'a > { w : & 'a mut W , } impl < 'a > _CLKOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERW < 'a > { w : & 'a mut W , } impl < 'a > _OVERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INACKW < 'a > { w : & 'a mut W , } impl < 'a > _INACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSNACKW < 'a > { w : & 'a mut W , } impl < 'a > _DSNACKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VAR_SYNCW < 'a > { w : & 'a mut W , } impl < 'a > _VAR_SYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INVDATAW < 'a > { w : & 'a mut W , } impl < 'a > _INVDATAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MAX_ITERATIONW < 'a > { w : & 'a mut W , } impl < 'a > _MAX_ITERATIONW < '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 _FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _FILTERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANW < 'a > { w : & 'a mut W , } impl < 'a > _MANW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MODSYNCW < 'a > { w : & 'a mut W , } impl < 'a > _MODSYNCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 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:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & self ) -> SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYNCR { bits } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & self ) -> PARR { PARR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & self ) -> NBSTOPR { NBSTOPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & self ) -> CHMODER { CHMODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & self ) -> MSBFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSBFR { bits } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & self ) -> MODE9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODE9R { bits } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & self ) -> CLKOR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKOR { bits } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & self ) -> OVERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERR { bits } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & self ) -> INACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INACKR { bits } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & self ) -> DSNACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSNACKR { bits } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & self ) -> VAR_SYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VAR_SYNCR { bits } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & self ) -> INVDATAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INVDATAR { bits } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & self ) -> MAX_ITERATIONR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MAX_ITERATIONR { bits } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & self ) -> FILTERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FILTERR { bits } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & self ) -> MANR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANR { bits } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & self ) -> MODSYNCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MODSYNCR { bits } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & self ) -> ONEBITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONEBITR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - Synchronous Mode Select" ] # [ inline ] pub fn sync ( & mut self ) -> _SYNCW { _SYNCW { w : self } } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & mut self ) -> _PARW { _PARW { w : self } } # [ doc = "Bits 12:13 - Number of Stop Bits" ] # [ inline ] pub fn nbstop ( & mut self ) -> _NBSTOPW { _NBSTOPW { w : self } } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & mut self ) -> _CHMODEW { _CHMODEW { w : self } } # [ doc = "Bit 16 - Bit Order" ] # [ inline ] pub fn msbf ( & mut self ) -> _MSBFW { _MSBFW { w : self } } # [ doc = "Bit 17 - 9-bit Character Length" ] # [ inline ] pub fn mode9 ( & mut self ) -> _MODE9W { _MODE9W { w : self } } # [ doc = "Bit 18 - Clock Output Select" ] # [ inline ] pub fn clko ( & mut self ) -> _CLKOW { _CLKOW { w : self } } # [ doc = "Bit 19 - Oversampling Mode" ] # [ inline ] pub fn over ( & mut self ) -> _OVERW { _OVERW { w : self } } # [ doc = "Bit 20 - Inhibit Non Acknowledge" ] # [ inline ] pub fn inack ( & mut self ) -> _INACKW { _INACKW { w : self } } # [ doc = "Bit 21 - Disable Successive NACK" ] # [ inline ] pub fn dsnack ( & mut self ) -> _DSNACKW { _DSNACKW { w : self } } # [ doc = "Bit 22 - Variable Synchronization of Command/Data Sync Start Frame Delimiter" ] # [ inline ] pub fn var_sync ( & mut self ) -> _VAR_SYNCW { _VAR_SYNCW { w : self } } # [ doc = "Bit 23 - Inverted Data" ] # [ inline ] pub fn invdata ( & mut self ) -> _INVDATAW { _INVDATAW { w : self } } # [ doc = "Bits 24:26 - Maximum Number of Automatic Iteration" ] # [ inline ] pub fn max_iteration ( & mut self ) -> _MAX_ITERATIONW { _MAX_ITERATIONW { w : self } } # [ doc = "Bit 28 - Infrared Receive Line Filter" ] # [ inline ] pub fn filter ( & mut self ) -> _FILTERW { _FILTERW { w : self } } # [ doc = "Bit 29 - Manchester Encoder/Decoder Enable" ] # [ inline ] pub fn man ( & mut self ) -> _MANW { _MANW { w : self } } # [ doc = "Bit 30 - Manchester Synchronization Mode" ] # [ inline ] pub fn modsync ( & mut self ) -> _MODSYNCW { _MODSYNCW { w : self } } # [ doc = "Bit 31 - Start Frame Delimiter Selector" ] # [ inline ] pub fn onebit ( & mut self ) -> _ONEBITW { _ONEBITW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr_spi_mode { # [ 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 :: MR_SPI_MODE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `USART_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USART_MODER { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USART_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USART_MODER :: SPI_MASTER => 0x0e , USART_MODER :: SPI_SLAVE => 0x0f , USART_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USART_MODER { match value { 14 => USART_MODER :: SPI_MASTER , 15 => USART_MODER :: SPI_SLAVE , i => USART_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SPI_MASTER`" ] # [ inline ] pub fn is_spi_master ( & self ) -> bool { * self == USART_MODER :: SPI_MASTER } # [ doc = "Checks if the value of the field is `SPI_SLAVE`" ] # [ inline ] pub fn is_spi_slave ( & self ) -> bool { * self == USART_MODER :: SPI_SLAVE } } # [ doc = "Possible values of the field `USCLKS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USCLKSR { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USCLKSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USCLKSR :: MCK => 0 , USCLKSR :: DIV => 0x01 , USCLKSR :: SCK => 0x03 , USCLKSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USCLKSR { match value { 0 => USCLKSR :: MCK , 1 => USCLKSR :: DIV , 3 => USCLKSR :: SCK , i => USCLKSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == USCLKSR :: MCK } # [ doc = "Checks if the value of the field is `DIV`" ] # [ inline ] pub fn is_div ( & self ) -> bool { * self == USCLKSR :: DIV } # [ doc = "Checks if the value of the field is `SCK`" ] # [ inline ] pub fn is_sck ( & self ) -> bool { * self == USCLKSR :: SCK } } # [ doc = "Possible values of the field `CHRL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHRLR { # [ doc = "Character length is 8 bits" ] _8_BIT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CHRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHRLR :: _8_BIT => 0x03 , CHRLR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHRLR { match value { 3 => CHRLR :: _8_BIT , i => CHRLR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_8_BIT`" ] # [ inline ] pub fn is_8_bit ( & self ) -> bool { * self == CHRLR :: _8_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 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 WRDBTR { bits : bool , } impl WRDBTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `USART_MODE`" ] pub enum USART_MODEW { # [ doc = "SPI master" ] SPI_MASTER , # [ doc = "SPI Slave" ] SPI_SLAVE } impl USART_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USART_MODEW :: SPI_MASTER => 14 , USART_MODEW :: SPI_SLAVE => 15 } } } # [ doc = r" Proxy" ] pub struct _USART_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _USART_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USART_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "SPI master" ] # [ inline ] pub fn spi_master ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_MASTER ) } # [ doc = "SPI Slave" ] # [ inline ] pub fn spi_slave ( self ) -> & 'a mut W { self . variant ( USART_MODEW :: SPI_SLAVE ) } # [ 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 } } # [ doc = "Values that can be written to the field `USCLKS`" ] pub enum USCLKSW { # [ doc = "master Clock MCK is selected" ] MCK , # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] DIV , # [ doc = "Serial Clock SLK is selected" ] SCK } impl USCLKSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USCLKSW :: MCK => 0 , USCLKSW :: DIV => 1 , USCLKSW :: SCK => 3 } } } # [ doc = r" Proxy" ] pub struct _USCLKSW < 'a > { w : & 'a mut W , } impl < 'a > _USCLKSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USCLKSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "master Clock MCK is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: MCK ) } # [ doc = "Internal Clock Divided MCK/DIV (DIV=8) is selected" ] # [ inline ] pub fn div ( self ) -> & 'a mut W { self . variant ( USCLKSW :: DIV ) } # [ doc = "Serial Clock SLK is selected" ] # [ inline ] pub fn sck ( self ) -> & 'a mut W { self . variant ( USCLKSW :: SCK ) } # [ 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 = "Values that can be written to the field `CHRL`" ] pub enum CHRLW { # [ doc = "Character length is 8 bits" ] _8_BIT } impl CHRLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHRLW :: _8_BIT => 3 } } } # [ doc = r" Proxy" ] pub struct _CHRLW < 'a > { w : & 'a mut W , } impl < 'a > _CHRLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHRLW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Character length is 8 bits" ] # [ inline ] pub fn _8_bit ( self ) -> & 'a mut W { self . variant ( CHRLW :: _8_BIT ) } # [ 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 _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 = 8 ; 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _WRDBTW < 'a > { w : & 'a mut W , } impl < 'a > _WRDBTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & self ) -> USART_MODER { USART_MODER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & self ) -> USCLKSR { USCLKSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & self ) -> CHRLR { CHRLR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & self ) -> CPHAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPHAR { bits } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & self ) -> CPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CPOLR { bits } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & self ) -> WRDBTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WRDBTR { bits } } } impl W { # [ doc = "Bits 0:3 - USART Mode of Operation" ] # [ inline ] pub fn usart_mode ( & mut self ) -> _USART_MODEW { _USART_MODEW { w : self } } # [ doc = "Bits 4:5 - Clock Selection" ] # [ inline ] pub fn usclks ( & mut self ) -> _USCLKSW { _USCLKSW { w : self } } # [ doc = "Bits 6:7 - Character Length" ] # [ inline ] pub fn chrl ( & mut self ) -> _CHRLW { _CHRLW { w : self } } # [ doc = "Bit 8 - SPI Clock Phase" ] # [ inline ] pub fn cpha ( & mut self ) -> _CPHAW { _CPHAW { w : self } } # [ doc = "Bit 16 - SPI Clock Polarity" ] # [ inline ] pub fn cpol ( & mut self ) -> _CPOLW { _CPOLW { w : self } } # [ doc = "Bit 20 - Wait Read Data Before Transfer" ] # [ inline ] pub fn wrdbt ( & mut self ) -> _WRDBTW { _WRDBTW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Enable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max number of Repetitions Reached Interrupt Enable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Enable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Enable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Enable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Enable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Enable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Enable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Enable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Enable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Enable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Enable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Enable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Enable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Enable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Enable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Enable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Enable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Enable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Enable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBRKW < 'a > { w : & 'a mut W , } impl < 'a > _RXBRKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ITERW < 'a > { w : & 'a mut W , } impl < 'a > _ITERW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 13 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CTSICW < 'a > { w : & 'a mut W , } impl < 'a > _CTSICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MANEW < 'a > { w : & 'a mut W , } impl < 'a > _MANEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 2 - Receiver Break Interrupt Disable" ] # [ inline ] pub fn rxbrk ( & mut self ) -> _RXBRKW { _RXBRKW { w : self } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - End of Transmit Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Enable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Disable" ] # [ inline ] pub fn iter ( & mut self ) -> _ITERW { _ITERW { w : self } } # [ doc = "Bit 11 - Buffer Empty Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Buffer Full Interrupt Disable (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Disable" ] # [ inline ] pub fn nack ( & mut self ) -> _NACKW { _NACKW { w : self } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Disable" ] # [ inline ] pub fn ctsic ( & mut self ) -> _CTSICW { _CTSICW { w : self } } # [ doc = "Bit 24 - Manchester Error Interrupt Disable" ] # [ inline ] pub fn mane ( & mut self ) -> _MANEW { _MANEW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_spi_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_SPI_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNREW < 'a > { w : & 'a mut W , } impl < 'a > _UNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Disable" ] # [ inline ] pub fn unre ( & mut self ) -> _UNREW { _UNREW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr_lin_mode { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR_LIN_MODE { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBKW < 'a > { w : & 'a mut W , } impl < 'a > _LINBKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIDW < 'a > { w : & 'a mut W , } impl < 'a > _LINIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINTCW < 'a > { w : & 'a mut W , } impl < 'a > _LINTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINBEW < 'a > { w : & 'a mut W , } impl < 'a > _LINBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINISFEW < 'a > { w : & 'a mut W , } impl < 'a > _LINISFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINIPEW < 'a > { w : & 'a mut W , } impl < 'a > _LINIPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINCEW < 'a > { w : & 'a mut W , } impl < 'a > _LINCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LINSNREW < 'a > { w : & 'a mut W , } impl < 'a > _LINSNREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - RXRDY Interrupt Disable" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - TXRDY Interrupt Disable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Overrun Error Interrupt Disable" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Framing Error Interrupt Disable" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Parity Error Interrupt Disable" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 8 - Time-out Interrupt Disable" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 9 - TXEMPTY Interrupt Disable" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Disable" ] # [ inline ] pub fn linbk ( & mut self ) -> _LINBKW { _LINBKW { w : self } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Disable" ] # [ inline ] pub fn linid ( & mut self ) -> _LINIDW { _LINIDW { w : self } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Disable" ] # [ inline ] pub fn lintc ( & mut self ) -> _LINTCW { _LINTCW { w : self } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Disable" ] # [ inline ] pub fn linbe ( & mut self ) -> _LINBEW { _LINBEW { w : self } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Disable" ] # [ inline ] pub fn linisfe ( & mut self ) -> _LINISFEW { _LINISFEW { w : self } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Disable" ] # [ inline ] pub fn linipe ( & mut self ) -> _LINIPEW { _LINIPEW { w : self } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Disable" ] # [ inline ] pub fn lince ( & mut self ) -> _LINCEW { _LINCEW { w : self } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Disable" ] # [ inline ] pub fn linsnre ( & mut self ) -> _LINSNREW { _LINSNREW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MANER { bits : bool , } impl MANER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Receiver Break Interrupt Mask" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receive Transfer Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmit Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached Interrupt Mask" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Buffer Empty Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Buffer Full Interrupt Mask (available in all USART modes of operation)" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt Mask" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Interrupt Mask" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 24 - Manchester Error Interrupt Mask" ] # [ inline ] pub fn mane ( & self ) -> MANER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANER { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - SPI Underrun Error Interrupt Mask" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - RXRDY Interrupt Mask" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - TXRDY Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error Interrupt Mask" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error Interrupt Mask" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error Interrupt Mask" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Time-out Interrupt Mask" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - TXEMPTY Interrupt Mask" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received Interrupt Mask" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received Interrupt Mask" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed Interrupt Mask" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 25 - LIN Bus Error Interrupt Mask" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error Interrupt Mask" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Interrupt Mask" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error Interrupt Mask" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error Interrupt Mask" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBRKR { bits : bool , } impl RXBRKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ITERR { bits : bool , } impl ITERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CTSICR { bits : bool , } impl CTSICR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 MANERRR { bits : bool , } impl MANERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 2 - Break Received/End of Break" ] # [ inline ] pub fn rxbrk ( & self ) -> RXBRKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBRKR { bits } } # [ doc = "Bit 3 - End of Receiver Transfer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmitter Transfer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Max Number of Repetitions Reached" ] # [ inline ] pub fn iter ( & self ) -> ITERR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ITERR { bits } } # [ doc = "Bit 11 - Transmission Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Reception Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - Non Acknowledge Interrupt" ] # [ inline ] pub fn nack ( & self ) -> NACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NACKR { bits } } # [ doc = "Bit 19 - Clear to Send Input Change Flag" ] # [ inline ] pub fn ctsic ( & self ) -> CTSICR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSICR { bits } } # [ doc = "Bit 23 - Image of CTS Input" ] # [ inline ] pub fn cts ( & self ) -> CTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTSR { bits } } # [ doc = "Bit 24 - Manchester Error" ] # [ inline ] pub fn manerr ( & self ) -> MANERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MANERRR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_SPI_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_spi_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_SPI_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNRER { bits : bool , } impl UNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 10 - Underrun Error" ] # [ inline ] pub fn unre ( & self ) -> UNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNRER { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Channel Status Register" ] pub struct CSR_LIN_MODE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod csr_lin_mode { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CSR_LIN_MODE { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBKR { bits : bool , } impl LINBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIDR { bits : bool , } impl LINIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINTCR { bits : bool , } impl LINTCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBLSR { bits : bool , } impl LINBLSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINBER { bits : bool , } impl LINBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINISFER { bits : bool , } impl LINISFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINIPER { bits : bool , } impl LINIPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINCER { bits : bool , } impl LINCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LINSNRER { bits : bool , } impl LINSNRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 8 - Receiver Time-out" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } # [ doc = "Bit 13 - LIN Break Sent or LIN Break Received" ] # [ inline ] pub fn linbk ( & self ) -> LINBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBKR { bits } } # [ doc = "Bit 14 - LIN Identifier Sent or LIN Identifier Received" ] # [ inline ] pub fn linid ( & self ) -> LINIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIDR { bits } } # [ doc = "Bit 15 - LIN Transfer Completed" ] # [ inline ] pub fn lintc ( & self ) -> LINTCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINTCR { bits } } # [ doc = "Bit 23 - LIN Bus Line Status" ] # [ inline ] pub fn linbls ( & self ) -> LINBLSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBLSR { bits } } # [ doc = "Bit 25 - LIN Bit Error" ] # [ inline ] pub fn linbe ( & self ) -> LINBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINBER { bits } } # [ doc = "Bit 26 - LIN Inconsistent Synch Field Error" ] # [ inline ] pub fn linisfe ( & self ) -> LINISFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINISFER { bits } } # [ doc = "Bit 27 - LIN Identifier Parity Error" ] # [ inline ] pub fn linipe ( & self ) -> LINIPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINIPER { bits } } # [ doc = "Bit 28 - LIN Checksum Error" ] # [ inline ] pub fn lince ( & self ) -> LINCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINCER { bits } } # [ doc = "Bit 29 - LIN Slave Not Responding Error" ] # [ inline ] pub fn linsnre ( & self ) -> LINSNRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LINSNRER { bits } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 RXCHRR { bits : u16 , } impl RXCHRR { # [ 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 RXSYNHR { bits : bool , } impl RXSYNHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:8 - Received Character" ] # [ inline ] pub fn rxchr ( & self ) -> RXCHRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCHRR { bits } } # [ doc = "Bit 15 - Received Sync" ] # [ inline ] pub fn rxsynh ( & self ) -> RXSYNHR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSYNHR { bits } } } } # [ doc = "Transmit Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCHRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCHRW < '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 } } # [ doc = r" Proxy" ] pub struct _TXSYNHW < 'a > { w : & 'a mut W , } impl < 'a > _TXSYNHW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:8 - Character to be Transmitted" ] # [ inline ] pub fn txchr ( & mut self ) -> _TXCHRW { _TXCHRW { w : self } } # [ doc = "Bit 15 - Sync Field to be Transmitted" ] # [ inline ] pub fn txsynh ( & mut self ) -> _TXSYNHW { _TXSYNHW { w : self } } } } # [ doc = "Baud Rate Generator Register" ] pub struct BRGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Baud Rate Generator Register" ] pub mod brgr { # [ 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 :: BRGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDR { bits : u16 , } impl CDR { # [ 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 FPR { bits : u8 , } impl FPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDW < 'a > { w : & 'a mut W , } impl < 'a > _CDW < '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 } } # [ doc = r" Proxy" ] pub struct _FPW < 'a > { w : & 'a mut W , } impl < 'a > _FPW < '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 = 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:15 - Clock Divider" ] # [ inline ] pub fn cd ( & self ) -> CDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; CDR { bits } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & self ) -> FPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FPR { 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 - Clock Divider" ] # [ inline ] pub fn cd ( & mut self ) -> _CDW { _CDW { w : self } } # [ doc = "Bits 16:18 - Fractional Part" ] # [ inline ] pub fn fp ( & mut self ) -> _FPW { _FPW { w : self } } } } # [ doc = "Receiver Time-out Register" ] pub struct RTOR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receiver Time-out 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 < F > ( & 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 < F > ( & 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 TOR { bits : u32 , } impl TOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TOW < 'a > { w : & 'a mut W , } impl < 'a > _TOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0001_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:16 - Time-out Value" ] # [ inline ] pub fn to ( & self ) -> TOR { let bits = { const MASK : u32 = 0x0001_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TOR { 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:16 - Time-out Value" ] # [ inline ] pub fn to ( & mut self ) -> _TOW { _TOW { w : self } } } } # [ doc = "Transmitter Timeguard Register" ] pub struct TTGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmitter Timeguard Register" ] pub mod ttgr { # [ 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 :: TTGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TGR { bits : u8 , } impl TGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _TGW < 'a > { w : & 'a mut W , } impl < 'a > _TGW < '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 - Timeguard Value" ] # [ inline ] pub fn tg ( & self ) -> TGR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TGR { 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 - Timeguard Value" ] # [ inline ] pub fn tg ( & mut self ) -> _TGW { _TGW { w : self } } } } # [ doc = "FI DI Ratio Register" ] pub struct FIDI { register : :: vcell :: VolatileCell < u32 > } # [ doc = "FI DI Ratio Register" ] pub mod fidi { # [ 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 :: FIDI { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FI_DI_RATIOR { bits : u16 , } impl FI_DI_RATIOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _FI_DI_RATIOW < 'a > { w : & 'a mut W , } impl < 'a > _FI_DI_RATIOW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & self ) -> FI_DI_RATIOR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; FI_DI_RATIOR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0174 } } # [ 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:10 - FI Over DI Ratio Value" ] # [ inline ] pub fn fi_di_ratio ( & mut self ) -> _FI_DI_RATIOW { _FI_DI_RATIOW { w : self } } } } # [ doc = "Number of Errors Register" ] pub struct NER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Number of Errors Register" ] pub mod ner { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: NER { # [ 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 NB_ERRORSR { bits : u8 , } impl NB_ERRORSR { # [ 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 - Number of Errors" ] # [ inline ] pub fn nb_errors ( & self ) -> NB_ERRORSR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NB_ERRORSR { bits } } } } # [ doc = "IrDA Filter Register" ] pub struct IF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "IrDA Filter Register" ] pub mod if_ { # [ 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 :: IF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IRDA_FILTERR { bits : u8 , } impl IRDA_FILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IRDA_FILTERW < 'a > { w : & 'a mut W , } impl < 'a > _IRDA_FILTERW < '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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & self ) -> IRDA_FILTERR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IRDA_FILTERR { 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 - IrDA Filter" ] # [ inline ] pub fn irda_filter ( & mut self ) -> _IRDA_FILTERW { _IRDA_FILTERW { w : self } } } } # [ doc = "Manchester Configuration Register" ] pub struct MAN { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Manchester Configuration Register" ] pub mod man { # [ 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 :: MAN { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TX_PLR { bits : u8 , } impl TX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `TX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TX_PPR :: ALL_ONE => 0 , TX_PPR :: ALL_ZERO => 0x01 , TX_PPR :: ZERO_ONE => 0x02 , TX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TX_PPR { match value { 0 => TX_PPR :: ALL_ONE , 1 => TX_PPR :: ALL_ZERO , 2 => TX_PPR :: ZERO_ONE , 3 => TX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == TX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == TX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == TX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == TX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct TX_MPOLR { bits : bool , } impl TX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RX_PLR { bits : u8 , } impl RX_PLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `RX_PP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RX_PPR { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RX_PPR :: ALL_ONE => 0 , RX_PPR :: ALL_ZERO => 0x01 , RX_PPR :: ZERO_ONE => 0x02 , RX_PPR :: ONE_ZERO => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RX_PPR { match value { 0 => RX_PPR :: ALL_ONE , 1 => RX_PPR :: ALL_ZERO , 2 => RX_PPR :: ZERO_ONE , 3 => RX_PPR :: ONE_ZERO , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `ALL_ONE`" ] # [ inline ] pub fn is_all_one ( & self ) -> bool { * self == RX_PPR :: ALL_ONE } # [ doc = "Checks if the value of the field is `ALL_ZERO`" ] # [ inline ] pub fn is_all_zero ( & self ) -> bool { * self == RX_PPR :: ALL_ZERO } # [ doc = "Checks if the value of the field is `ZERO_ONE`" ] # [ inline ] pub fn is_zero_one ( & self ) -> bool { * self == RX_PPR :: ZERO_ONE } # [ doc = "Checks if the value of the field is `ONE_ZERO`" ] # [ inline ] pub fn is_one_zero ( & self ) -> bool { * self == RX_PPR :: ONE_ZERO } } # [ doc = r" Value of the field" ] pub struct RX_MPOLR { bits : bool , } impl RX_MPOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ONER { bits : bool , } impl ONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRIFTR { bits : bool , } impl DRIFTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PLW < '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 } } # [ doc = "Values that can be written to the field `TX_PP`" ] pub enum TX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl TX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TX_PPW :: ALL_ONE => 0 , TX_PPW :: ALL_ZERO => 1 , TX_PPW :: ZERO_ONE => 2 , TX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _TX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _TX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( TX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _TX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _TX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RX_PLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PLW < '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 = "Values that can be written to the field `RX_PP`" ] pub enum RX_PPW { # [ doc = "The preamble is composed of '1's" ] ALL_ONE , # [ doc = "The preamble is composed of '0's" ] ALL_ZERO , # [ doc = "The preamble is composed of '01's" ] ZERO_ONE , # [ doc = "The preamble is composed of '10's" ] ONE_ZERO } impl RX_PPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RX_PPW :: ALL_ONE => 0 , RX_PPW :: ALL_ZERO => 1 , RX_PPW :: ZERO_ONE => 2 , RX_PPW :: ONE_ZERO => 3 } } } # [ doc = r" Proxy" ] pub struct _RX_PPW < 'a > { w : & 'a mut W , } impl < 'a > _RX_PPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RX_PPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The preamble is composed of '1's" ] # [ inline ] pub fn all_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ONE ) } # [ doc = "The preamble is composed of '0's" ] # [ inline ] pub fn all_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ALL_ZERO ) } # [ doc = "The preamble is composed of '01's" ] # [ inline ] pub fn zero_one ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ZERO_ONE ) } # [ doc = "The preamble is composed of '10's" ] # [ inline ] pub fn one_zero ( self ) -> & 'a mut W { self . variant ( RX_PPW :: ONE_ZERO ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _RX_MPOLW < 'a > { w : & 'a mut W , } impl < 'a > _RX_MPOLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ONEW < 'a > { w : & 'a mut W , } impl < 'a > _ONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRIFTW < 'a > { w : & 'a mut W , } impl < 'a > _DRIFTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & self ) -> TX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TX_PLR { bits } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & self ) -> TX_PPR { TX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & self ) -> TX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TX_MPOLR { bits } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & self ) -> RX_PLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RX_PLR { bits } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & self ) -> RX_PPR { RX_PPR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & self ) -> RX_MPOLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RX_MPOLR { bits } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & self ) -> ONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONER { bits } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & self ) -> DRIFTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRIFTR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0xb001_1004 } } # [ 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 - Transmitter Preamble Length" ] # [ inline ] pub fn tx_pl ( & mut self ) -> _TX_PLW { _TX_PLW { w : self } } # [ doc = "Bits 8:9 - Transmitter Preamble Pattern" ] # [ inline ] pub fn tx_pp ( & mut self ) -> _TX_PPW { _TX_PPW { w : self } } # [ doc = "Bit 12 - Transmitter Manchester Polarity" ] # [ inline ] pub fn tx_mpol ( & mut self ) -> _TX_MPOLW { _TX_MPOLW { w : self } } # [ doc = "Bits 16:19 - Receiver Preamble Length" ] # [ inline ] pub fn rx_pl ( & mut self ) -> _RX_PLW { _RX_PLW { w : self } } # [ doc = "Bits 24:25 - Receiver Preamble Pattern detected" ] # [ inline ] pub fn rx_pp ( & mut self ) -> _RX_PPW { _RX_PPW { w : self } } # [ doc = "Bit 28 - Receiver Manchester Polarity" ] # [ inline ] pub fn rx_mpol ( & mut self ) -> _RX_MPOLW { _RX_MPOLW { w : self } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & mut self ) -> _ONEW { _ONEW { w : self } } # [ doc = "Bit 30 - Drift Compensation" ] # [ inline ] pub fn drift ( & mut self ) -> _DRIFTW { _DRIFTW { w : self } } } } # [ doc = "LIN Mode Register" ] pub struct LINMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Mode Register" ] pub mod linmr { # [ 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 :: LINMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `NACT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NACTR { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NACTR :: PUBLISH => 0 , NACTR :: SUBSCRIBE => 0x01 , NACTR :: IGNORE => 0x02 , NACTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NACTR { match value { 0 => NACTR :: PUBLISH , 1 => NACTR :: SUBSCRIBE , 2 => NACTR :: IGNORE , i => NACTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PUBLISH`" ] # [ inline ] pub fn is_publish ( & self ) -> bool { * self == NACTR :: PUBLISH } # [ doc = "Checks if the value of the field is `SUBSCRIBE`" ] # [ inline ] pub fn is_subscribe ( & self ) -> bool { * self == NACTR :: SUBSCRIBE } # [ doc = "Checks if the value of the field is `IGNORE`" ] # [ inline ] pub fn is_ignore ( & self ) -> bool { * self == NACTR :: IGNORE } } # [ doc = r" Value of the field" ] pub struct PARDISR { bits : bool , } impl PARDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKDISR { bits : bool , } impl CHKDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHKTYPR { bits : bool , } impl CHKTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLMR { bits : bool , } impl DLMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSDISR { bits : bool , } impl FSDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WKUPTYPR { bits : bool , } impl WKUPTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLCR { bits : u8 , } impl DLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PDCMR { bits : bool , } impl PDCMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `NACT`" ] pub enum NACTW { # [ doc = "The USART transmits the response." ] PUBLISH , # [ doc = "The USART receives the response." ] SUBSCRIBE , # [ doc = "The USART does not transmit and does not receive the response." ] IGNORE } impl NACTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NACTW :: PUBLISH => 0 , NACTW :: SUBSCRIBE => 1 , NACTW :: IGNORE => 2 } } } # [ doc = r" Proxy" ] pub struct _NACTW < 'a > { w : & 'a mut W , } impl < 'a > _NACTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NACTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The USART transmits the response." ] # [ inline ] pub fn publish ( self ) -> & 'a mut W { self . variant ( NACTW :: PUBLISH ) } # [ doc = "The USART receives the response." ] # [ inline ] pub fn subscribe ( self ) -> & 'a mut W { self . variant ( NACTW :: SUBSCRIBE ) } # [ doc = "The USART does not transmit and does not receive the response." ] # [ inline ] pub fn ignore ( self ) -> & 'a mut W { self . variant ( NACTW :: IGNORE ) } # [ 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 _PARDISW < 'a > { w : & 'a mut W , } impl < 'a > _PARDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKDISW < 'a > { w : & 'a mut W , } impl < 'a > _CHKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHKTYPW < 'a > { w : & 'a mut W , } impl < 'a > _CHKTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLMW < 'a > { w : & 'a mut W , } impl < 'a > _DLMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSDISW < 'a > { w : & 'a mut W , } impl < 'a > _FSDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WKUPTYPW < 'a > { w : & 'a mut W , } impl < 'a > _WKUPTYPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLCW < 'a > { w : & 'a mut W , } impl < 'a > _DLCW < '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 _PDCMW < 'a > { w : & 'a mut W , } impl < 'a > _PDCMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:1 - LIN Node Action" ] # [ inline ] pub fn nact ( & self ) -> NACTR { NACTR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & self ) -> PARDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARDISR { bits } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & self ) -> CHKDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKDISR { bits } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & self ) -> CHKTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHKTYPR { bits } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & self ) -> DLMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLMR { bits } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & self ) -> FSDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSDISR { bits } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & self ) -> WKUPTYPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WKUPTYPR { bits } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & self ) -> DLCR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DLCR { bits } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & self ) -> PDCMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PDCMR { 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 - LIN Node Action" ] # [ inline ] pub fn nact ( & mut self ) -> _NACTW { _NACTW { w : self } } # [ doc = "Bit 2 - Parity Disable" ] # [ inline ] pub fn pardis ( & mut self ) -> _PARDISW { _PARDISW { w : self } } # [ doc = "Bit 3 - Checksum Disable" ] # [ inline ] pub fn chkdis ( & mut self ) -> _CHKDISW { _CHKDISW { w : self } } # [ doc = "Bit 4 - Checksum Type" ] # [ inline ] pub fn chktyp ( & mut self ) -> _CHKTYPW { _CHKTYPW { w : self } } # [ doc = "Bit 5 - Data Length Mode" ] # [ inline ] pub fn dlm ( & mut self ) -> _DLMW { _DLMW { w : self } } # [ doc = "Bit 6 - Frame Slot Mode Disable" ] # [ inline ] pub fn fsdis ( & mut self ) -> _FSDISW { _FSDISW { w : self } } # [ doc = "Bit 7 - Wakeup Signal Type" ] # [ inline ] pub fn wkuptyp ( & mut self ) -> _WKUPTYPW { _WKUPTYPW { w : self } } # [ doc = "Bits 8:15 - Data Length Control" ] # [ inline ] pub fn dlc ( & mut self ) -> _DLCW { _DLCW { w : self } } # [ doc = "Bit 16 - PDC Mode" ] # [ inline ] pub fn pdcm ( & mut self ) -> _PDCMW { _PDCMW { w : self } } } } # [ doc = "LIN Identifier Register" ] pub struct LINIR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Identifier Register" ] pub mod linir { # [ 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 :: LINIR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IDCHRR { bits : u8 , } impl IDCHRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IDCHRW < 'a > { w : & 'a mut W , } impl < 'a > _IDCHRW < '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 - Identifier Character" ] # [ inline ] pub fn idchr ( & self ) -> IDCHRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IDCHRR { 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 - Identifier Character" ] # [ inline ] pub fn idchr ( & mut self ) -> _IDCHRW { _IDCHRW { w : self } } } } # [ doc = "LIN Baud Rate Register" ] pub struct LINBRR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "LIN Baud Rate Register" ] pub mod linbrr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LINBRR { # [ 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 LINCDR { bits : u16 , } impl LINCDR { # [ 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 LINFPR { bits : u8 , } impl LINFPR { # [ 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:15 - Clock Divider after Synchronization" ] # [ inline ] pub fn lincd ( & self ) -> LINCDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; LINCDR { bits } } # [ doc = "Bits 16:18 - Fractional Part after Synchronization" ] # [ inline ] pub fn linfp ( & self ) -> LINFPR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; LINFPR { bits } } } } # [ doc = "Write Protection Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0055_5341 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5591873 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5591873 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protection Key" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protection Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "USB On-The-Go Interface" ] pub struct UOTGHS { _marker : PhantomData < * const ( ) > } unsafe impl Send for UOTGHS { } impl UOTGHS { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const uotghs :: RegisterBlock { 0x400a_c000 as * const _ } } impl Deref for UOTGHS { type Target = uotghs :: RegisterBlock ; fn deref ( & self ) -> & uotghs :: RegisterBlock { unsafe { & * UOTGHS :: ptr ( ) } } } # [ doc = "USB On-The-Go Interface" ] pub mod uotghs { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Device General Control Register" ] pub devctrl : DEVCTRL , # [ doc = "0x04 - Device Global Interrupt Status Register" ] pub devisr : DEVISR , # [ doc = "0x08 - Device Global Interrupt Clear Register" ] pub devicr : DEVICR , # [ doc = "0x0c - Device Global Interrupt Set Register" ] pub devifr : DEVIFR , # [ doc = "0x10 - Device Global Interrupt Mask Register" ] pub devimr : DEVIMR , # [ doc = "0x14 - Device Global Interrupt Disable Register" ] pub devidr : DEVIDR , # [ doc = "0x18 - Device Global Interrupt Enable Register" ] pub devier : DEVIER , # [ doc = "0x1c - Device Endpoint Register" ] pub devept : DEVEPT , # [ doc = "0x20 - Device Frame Number Register" ] pub devfnum : DEVFNUM , _reserved9 : [ u8 ; 220usize ] , # [ doc = "0x100 - Device Endpoint Configuration Register (n = 0)" ] pub deveptcfg : [ DEVEPTCFG ; 10 ] , _reserved10 : [ u8 ; 8usize ] , # [ doc = "Device Endpoint Status Register (n = 0)" ] pub deveptisr : DEVEPTISR_UNION , _reserved11 : [ u8 ; 8usize ] , # [ doc = "Device Endpoint Clear Register (n = 0)" ] pub devepticr : DEVEPTICR_UNION , _reserved12 : [ u8 ; 8usize ] , # [ doc = "Device Endpoint Set Register (n = 0)" ] pub deveptifr : DEVEPTIFR_UNION , _reserved13 : [ u8 ; 8usize ] , # [ doc = "Device Endpoint Mask Register (n = 0)" ] pub deveptimr : DEVEPTIMR_UNION , _reserved14 : [ u8 ; 8usize ] , # [ doc = "Device Endpoint Enable Register (n = 0)" ] pub deveptier : DEVEPTIER_UNION , _reserved15 : [ u8 ; 8usize ] , # [ doc = "Device Endpoint Disable Register (n = 0)" ] pub deveptidr : DEVEPTIDR_UNION , _reserved16 : [ u8 ; 200usize ] , # [ doc = "0x310 - Device DMA Channel Next Descriptor Address Register (n = 1)" ] pub devdmanxtdsc1 : DEVDMANXTDSC1 , # [ doc = "0x314 - Device DMA Channel Address Register (n = 1)" ] pub devdmaaddress1 : DEVDMAADDRESS1 , # [ doc = "0x318 - Device DMA Channel Control Register (n = 1)" ] pub devdmacontrol1 : DEVDMACONTROL1 , # [ doc = "0x31c - Device DMA Channel Status Register (n = 1)" ] pub devdmastatus1 : DEVDMASTATUS1 , # [ doc = "0x320 - Device DMA Channel Next Descriptor Address Register (n = 2)" ] pub devdmanxtdsc2 : DEVDMANXTDSC2 , # [ doc = "0x324 - Device DMA Channel Address Register (n = 2)" ] pub devdmaaddress2 : DEVDMAADDRESS2 , # [ doc = "0x328 - Device DMA Channel Control Register (n = 2)" ] pub devdmacontrol2 : DEVDMACONTROL2 , # [ doc = "0x32c - Device DMA Channel Status Register (n = 2)" ] pub devdmastatus2 : DEVDMASTATUS2 , # [ doc = "0x330 - Device DMA Channel Next Descriptor Address Register (n = 3)" ] pub devdmanxtdsc3 : DEVDMANXTDSC3 , # [ doc = "0x334 - Device DMA Channel Address Register (n = 3)" ] pub devdmaaddress3 : DEVDMAADDRESS3 , # [ doc = "0x338 - Device DMA Channel Control Register (n = 3)" ] pub devdmacontrol3 : DEVDMACONTROL3 , # [ doc = "0x33c - Device DMA Channel Status Register (n = 3)" ] pub devdmastatus3 : DEVDMASTATUS3 , # [ doc = "0x340 - Device DMA Channel Next Descriptor Address Register (n = 4)" ] pub devdmanxtdsc4 : DEVDMANXTDSC4 , # [ doc = "0x344 - Device DMA Channel Address Register (n = 4)" ] pub devdmaaddress4 : DEVDMAADDRESS4 , # [ doc = "0x348 - Device DMA Channel Control Register (n = 4)" ] pub devdmacontrol4 : DEVDMACONTROL4 , # [ doc = "0x34c - Device DMA Channel Status Register (n = 4)" ] pub devdmastatus4 : DEVDMASTATUS4 , # [ doc = "0x350 - Device DMA Channel Next Descriptor Address Register (n = 5)" ] pub devdmanxtdsc5 : DEVDMANXTDSC5 , # [ doc = "0x354 - Device DMA Channel Address Register (n = 5)" ] pub devdmaaddress5 : DEVDMAADDRESS5 , # [ doc = "0x358 - Device DMA Channel Control Register (n = 5)" ] pub devdmacontrol5 : DEVDMACONTROL5 , # [ doc = "0x35c - Device DMA Channel Status Register (n = 5)" ] pub devdmastatus5 : DEVDMASTATUS5 , # [ doc = "0x360 - Device DMA Channel Next Descriptor Address Register (n = 6)" ] pub devdmanxtdsc6 : DEVDMANXTDSC6 , # [ doc = "0x364 - Device DMA Channel Address Register (n = 6)" ] pub devdmaaddress6 : DEVDMAADDRESS6 , # [ doc = "0x368 - Device DMA Channel Control Register (n = 6)" ] pub devdmacontrol6 : DEVDMACONTROL6 , # [ doc = "0x36c - Device DMA Channel Status Register (n = 6)" ] pub devdmastatus6 : DEVDMASTATUS6 , # [ doc = "0x370 - Device DMA Channel Next Descriptor Address Register (n = 7)" ] pub devdmanxtdsc7 : DEVDMANXTDSC7 , # [ doc = "0x374 - Device DMA Channel Address Register (n = 7)" ] pub devdmaaddress7 : DEVDMAADDRESS7 , # [ doc = "0x378 - Device DMA Channel Control Register (n = 7)" ] pub devdmacontrol7 : DEVDMACONTROL7 , # [ doc = "0x37c - Device DMA Channel Status Register (n = 7)" ] pub devdmastatus7 : DEVDMASTATUS7 , _reserved44 : [ u8 ; 128usize ] , # [ doc = "0x400 - Host General Control Register" ] pub hstctrl : HSTCTRL , # [ doc = "0x404 - Host Global Interrupt Status Register" ] pub hstisr : HSTISR , # [ doc = "0x408 - Host Global Interrupt Clear Register" ] pub hsticr : HSTICR , # [ doc = "0x40c - Host Global Interrupt Set Register" ] pub hstifr : HSTIFR , # [ doc = "0x410 - Host Global Interrupt Mask Register" ] pub hstimr : HSTIMR , # [ doc = "0x414 - Host Global Interrupt Disable Register" ] pub hstidr : HSTIDR , # [ doc = "0x418 - Host Global Interrupt Enable Register" ] pub hstier : HSTIER , # [ doc = "0x41c - Host Pipe Register" ] pub hstpip : HSTPIP , # [ doc = "0x420 - Host Frame Number Register" ] pub hstfnum : HSTFNUM , # [ doc = "0x424 - Host Address 1 Register" ] pub hstaddr1 : HSTADDR1 , # [ doc = "0x428 - Host Address 2 Register" ] pub hstaddr2 : HSTADDR2 , # [ doc = "0x42c - Host Address 3 Register" ] pub hstaddr3 : HSTADDR3 , _reserved56 : [ u8 ; 208usize ] , # [ doc = "Host Pipe Configuration Register (n = 0)" ] pub hstpipcfg : HSTPIPCFG_UNION , _reserved57 : [ u8 ; 8usize ] , # [ doc = "Host Pipe Status Register (n = 0)" ] pub hstpipisr : HSTPIPISR_UNION , _reserved58 : [ u8 ; 8usize ] , # [ doc = "Host Pipe Clear Register (n = 0)" ] pub hstpipicr : HSTPIPICR_UNION , _reserved59 : [ u8 ; 8usize ] , # [ doc = "Host Pipe Set Register (n = 0)" ] pub hstpipifr : HSTPIPIFR_UNION , _reserved60 : [ u8 ; 8usize ] , # [ doc = "Host Pipe Mask Register (n = 0)" ] pub hstpipimr : HSTPIPIMR_UNION , _reserved61 : [ u8 ; 8usize ] , # [ doc = "Host Pipe Enable Register (n = 0)" ] pub hstpipier : HSTPIPIER_UNION , _reserved62 : [ u8 ; 8usize ] , # [ doc = "Host Pipe Disable Register (n = 0)" ] pub hstpipidr : HSTPIPIDR_UNION , _reserved63 : [ u8 ; 8usize ] , # [ doc = "0x650 - Host Pipe IN Request Register (n = 0)" ] pub hstpipinrq : [ HSTPIPINRQ ; 10 ] , _reserved64 : [ u8 ; 8usize ] , # [ doc = "0x680 - Host Pipe Error Register (n = 0)" ] pub hstpiperr : [ HSTPIPERR ; 10 ] , _reserved65 : [ u8 ; 104usize ] , # [ doc = "0x710 - Host DMA Channel Next Descriptor Address Register (n = 1)" ] pub hstdmanxtdsc1 : HSTDMANXTDSC1 , # [ doc = "0x714 - Host DMA Channel Address Register (n = 1)" ] pub hstdmaaddress1 : HSTDMAADDRESS1 , # [ doc = "0x718 - Host DMA Channel Control Register (n = 1)" ] pub hstdmacontrol1 : HSTDMACONTROL1 , # [ doc = "0x71c - Host DMA Channel Status Register (n = 1)" ] pub hstdmastatus1 : HSTDMASTATUS1 , # [ doc = "0x720 - Host DMA Channel Next Descriptor Address Register (n = 2)" ] pub hstdmanxtdsc2 : HSTDMANXTDSC2 , # [ doc = "0x724 - Host DMA Channel Address Register (n = 2)" ] pub hstdmaaddress2 : HSTDMAADDRESS2 , # [ doc = "0x728 - Host DMA Channel Control Register (n = 2)" ] pub hstdmacontrol2 : HSTDMACONTROL2 , # [ doc = "0x72c - Host DMA Channel Status Register (n = 2)" ] pub hstdmastatus2 : HSTDMASTATUS2 , # [ doc = "0x730 - Host DMA Channel Next Descriptor Address Register (n = 3)" ] pub hstdmanxtdsc3 : HSTDMANXTDSC3 , # [ doc = "0x734 - Host DMA Channel Address Register (n = 3)" ] pub hstdmaaddress3 : HSTDMAADDRESS3 , # [ doc = "0x738 - Host DMA Channel Control Register (n = 3)" ] pub hstdmacontrol3 : HSTDMACONTROL3 , # [ doc = "0x73c - Host DMA Channel Status Register (n = 3)" ] pub hstdmastatus3 : HSTDMASTATUS3 , # [ doc = "0x740 - Host DMA Channel Next Descriptor Address Register (n = 4)" ] pub hstdmanxtdsc4 : HSTDMANXTDSC4 , # [ doc = "0x744 - Host DMA Channel Address Register (n = 4)" ] pub hstdmaaddress4 : HSTDMAADDRESS4 , # [ doc = "0x748 - Host DMA Channel Control Register (n = 4)" ] pub hstdmacontrol4 : HSTDMACONTROL4 , # [ doc = "0x74c - Host DMA Channel Status Register (n = 4)" ] pub hstdmastatus4 : HSTDMASTATUS4 , # [ doc = "0x750 - Host DMA Channel Next Descriptor Address Register (n = 5)" ] pub hstdmanxtdsc5 : HSTDMANXTDSC5 , # [ doc = "0x754 - Host DMA Channel Address Register (n = 5)" ] pub hstdmaaddress5 : HSTDMAADDRESS5 , # [ doc = "0x758 - Host DMA Channel Control Register (n = 5)" ] pub hstdmacontrol5 : HSTDMACONTROL5 , # [ doc = "0x75c - Host DMA Channel Status Register (n = 5)" ] pub hstdmastatus5 : HSTDMASTATUS5 , # [ doc = "0x760 - Host DMA Channel Next Descriptor Address Register (n = 6)" ] pub hstdmanxtdsc6 : HSTDMANXTDSC6 , # [ doc = "0x764 - Host DMA Channel Address Register (n = 6)" ] pub hstdmaaddress6 : HSTDMAADDRESS6 , # [ doc = "0x768 - Host DMA Channel Control Register (n = 6)" ] pub hstdmacontrol6 : HSTDMACONTROL6 , # [ doc = "0x76c - Host DMA Channel Status Register (n = 6)" ] pub hstdmastatus6 : HSTDMASTATUS6 , # [ doc = "0x770 - Host DMA Channel Next Descriptor Address Register (n = 7)" ] pub hstdmanxtdsc7 : HSTDMANXTDSC7 , # [ doc = "0x774 - Host DMA Channel Address Register (n = 7)" ] pub hstdmaaddress7 : HSTDMAADDRESS7 , # [ doc = "0x778 - Host DMA Channel Control Register (n = 7)" ] pub hstdmacontrol7 : HSTDMACONTROL7 , # [ doc = "0x77c - Host DMA Channel Status Register (n = 7)" ] pub hstdmastatus7 : HSTDMASTATUS7 , _reserved93 : [ u8 ; 128usize ] , # [ doc = "0x800 - General Control Register" ] pub ctrl : CTRL , # [ doc = "0x804 - General Status Register" ] pub sr : SR , # [ doc = "0x808 - General Status Clear Register" ] pub scr : SCR , # [ doc = "0x80c - General Status Set Register" ] pub sfr : SFR , _reserved97 : [ u8 ; 28usize ] , # [ doc = "0x82c - General Finite State Machine Register" ] pub fsm : FSM , } # [ doc = "Device Endpoint Status Register (n = 0)" ] # [ repr ( C ) ] pub union DEVEPTISR_UNION { # [ doc = "0x130 - Device Endpoint Status Register (n = 0)" ] pub deveptisr0_isoenpt : DEVEPTISR0_ISOENPT , # [ doc = "0x130 - Device Endpoint Status Register (n = 0)" ] pub deveptisr : [ DEVEPTISR ; 10 ] , } # [ doc = "Device Endpoint Clear Register (n = 0)" ] # [ repr ( C ) ] pub union DEVEPTICR_UNION { # [ doc = "0x160 - Device Endpoint Clear Register (n = 0)" ] pub devepticr0_isoenpt : DEVEPTICR0_ISOENPT , # [ doc = "0x160 - Device Endpoint Clear Register (n = 0)" ] pub devepticr : [ DEVEPTICR ; 10 ] , } # [ doc = "Device Endpoint Set Register (n = 0)" ] # [ repr ( C ) ] pub union DEVEPTIFR_UNION { # [ doc = "0x190 - Device Endpoint Set Register (n = 0)" ] pub deveptifr0_isoenpt : DEVEPTIFR0_ISOENPT , # [ doc = "0x190 - Device Endpoint Set Register (n = 0)" ] pub deveptifr : [ DEVEPTIFR ; 10 ] , } # [ doc = "Device Endpoint Mask Register (n = 0)" ] # [ repr ( C ) ] pub union DEVEPTIMR_UNION { # [ doc = "0x1c0 - Device Endpoint Mask Register (n = 0)" ] pub deveptimr0_isoenpt : DEVEPTIMR0_ISOENPT , # [ doc = "0x1c0 - Device Endpoint Mask Register (n = 0)" ] pub deveptimr : [ DEVEPTIMR ; 10 ] , } # [ doc = "Device Endpoint Enable Register (n = 0)" ] # [ repr ( C ) ] pub union DEVEPTIER_UNION { # [ doc = "0x1f0 - Device Endpoint Enable Register (n = 0)" ] pub deveptier0_isoenpt : DEVEPTIER0_ISOENPT , # [ doc = "0x1f0 - Device Endpoint Enable Register (n = 0)" ] pub deveptier : [ DEVEPTIER ; 10 ] , } # [ doc = "Device Endpoint Disable Register (n = 0)" ] # [ repr ( C ) ] pub union DEVEPTIDR_UNION { # [ doc = "0x220 - Device Endpoint Disable Register (n = 0)" ] pub deveptidr0_isoenpt : DEVEPTIDR0_ISOENPT , # [ doc = "0x220 - Device Endpoint Disable Register (n = 0)" ] pub deveptidr : [ DEVEPTIDR ; 10 ] , } # [ doc = "Host Pipe Configuration Register (n = 0)" ] # [ repr ( C ) ] pub union HSTPIPCFG_UNION { # [ doc = "0x500 - Host Pipe Configuration Register (n = 0)" ] pub hstpipcfg0_hsbohscp : HSTPIPCFG0_HSBOHSCP , # [ doc = "0x500 - Host Pipe Configuration Register (n = 0)" ] pub hstpipcfg : [ HSTPIPCFG ; 10 ] , } # [ doc = "Host Pipe Status Register (n = 0)" ] # [ repr ( C ) ] pub union HSTPIPISR_UNION { # [ doc = "0x530 - Host Pipe Status Register (n = 0)" ] pub hstpipisr0_isopipes : HSTPIPISR0_ISOPIPES , # [ doc = "0x530 - Host Pipe Status Register (n = 0)" ] pub hstpipisr0_intpipes : HSTPIPISR0_INTPIPES , # [ doc = "0x530 - Host Pipe Status Register (n = 0)" ] pub hstpipisr : [ HSTPIPISR ; 10 ] , } # [ doc = "Host Pipe Clear Register (n = 0)" ] # [ repr ( C ) ] pub union HSTPIPICR_UNION { # [ doc = "0x560 - Host Pipe Clear Register (n = 0)" ] pub hstpipicr0_isopipes : HSTPIPICR0_ISOPIPES , # [ doc = "0x560 - Host Pipe Clear Register (n = 0)" ] pub hstpipicr0_intpipes : HSTPIPICR0_INTPIPES , # [ doc = "0x560 - Host Pipe Clear Register (n = 0)" ] pub hstpipicr : [ HSTPIPICR ; 10 ] , } # [ doc = "Host Pipe Set Register (n = 0)" ] # [ repr ( C ) ] pub union HSTPIPIFR_UNION { # [ doc = "0x590 - Host Pipe Set Register (n = 0)" ] pub hstpipifr0_isopipes : HSTPIPIFR0_ISOPIPES , # [ doc = "0x590 - Host Pipe Set Register (n = 0)" ] pub hstpipifr0_intpipes : HSTPIPIFR0_INTPIPES , # [ doc = "0x590 - Host Pipe Set Register (n = 0)" ] pub hstpipifr : [ HSTPIPIFR ; 10 ] , } # [ doc = "Host Pipe Mask Register (n = 0)" ] # [ repr ( C ) ] pub union HSTPIPIMR_UNION { # [ doc = "0x5c0 - Host Pipe Mask Register (n = 0)" ] pub hstpipimr0_isopipes : HSTPIPIMR0_ISOPIPES , # [ doc = "0x5c0 - Host Pipe Mask Register (n = 0)" ] pub hstpipimr0_intpipes : HSTPIPIMR0_INTPIPES , # [ doc = "0x5c0 - Host Pipe Mask Register (n = 0)" ] pub hstpipimr : [ HSTPIPIMR ; 10 ] , } # [ doc = "Host Pipe Enable Register (n = 0)" ] # [ repr ( C ) ] pub union HSTPIPIER_UNION { # [ doc = "0x5f0 - Host Pipe Enable Register (n = 0)" ] pub hstpipier0_isopipes : HSTPIPIER0_ISOPIPES , # [ doc = "0x5f0 - Host Pipe Enable Register (n = 0)" ] pub hstpipier0_intpipes : HSTPIPIER0_INTPIPES , # [ doc = "0x5f0 - Host Pipe Enable Register (n = 0)" ] pub hstpipier : [ HSTPIPIER ; 10 ] , } # [ doc = "Host Pipe Disable Register (n = 0)" ] # [ repr ( C ) ] pub union HSTPIPIDR_UNION { # [ doc = "0x620 - Host Pipe Disable Register (n = 0)" ] pub hstpipidr0_isopipes : HSTPIPIDR0_ISOPIPES , # [ doc = "0x620 - Host Pipe Disable Register (n = 0)" ] pub hstpipidr0_intpipes : HSTPIPIDR0_INTPIPES , # [ doc = "0x620 - Host Pipe Disable Register (n = 0)" ] pub hstpipidr : [ HSTPIPIDR ; 10 ] , } # [ doc = "Device General Control Register" ] pub struct DEVCTRL { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device General Control Register" ] pub mod devctrl { # [ 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 :: DEVCTRL { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 UADDR { bits : u8 , } impl UADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct ADDENR { bits : bool , } impl ADDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DETACHR { bits : bool , } impl DETACHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RMWKUPR { bits : bool , } impl RMWKUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `SPDCONF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SPDCONFR { # [ doc = "The peripheral starts in full-speed mode and performs a high-speed reset to switch to the high-speed mode if the host is high-speed capable." ] NORMAL , # [ doc = "For a better consumption, if high-speed is not needed." ] LOW_POWER , # [ doc = "Forced high speed." ] HIGH_SPEED , # [ doc = "The peripheral remains in full-speed mode whatever the host speed capability." ] FORCED_FS } impl SPDCONFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SPDCONFR :: NORMAL => 0 , SPDCONFR :: LOW_POWER => 0x01 , SPDCONFR :: HIGH_SPEED => 0x02 , SPDCONFR :: FORCED_FS => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SPDCONFR { match value { 0 => SPDCONFR :: NORMAL , 1 => SPDCONFR :: LOW_POWER , 2 => SPDCONFR :: HIGH_SPEED , 3 => SPDCONFR :: FORCED_FS , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == SPDCONFR :: NORMAL } # [ doc = "Checks if the value of the field is `LOW_POWER`" ] # [ inline ] pub fn is_low_power ( & self ) -> bool { * self == SPDCONFR :: LOW_POWER } # [ doc = "Checks if the value of the field is `HIGH_SPEED`" ] # [ inline ] pub fn is_high_speed ( & self ) -> bool { * self == SPDCONFR :: HIGH_SPEED } # [ doc = "Checks if the value of the field is `FORCED_FS`" ] # [ inline ] pub fn is_forced_fs ( & self ) -> bool { * self == SPDCONFR :: FORCED_FS } } # [ doc = r" Value of the field" ] pub struct LSR { bits : bool , } impl LSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTJR { bits : bool , } impl TSTJR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTKR { bits : bool , } impl TSTKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTPCKTR { bits : bool , } impl TSTPCKTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OPMODE2R { bits : bool , } impl OPMODE2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _UADDW < 'a > { w : & 'a mut W , } impl < 'a > _UADDW < '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 } } # [ doc = r" Proxy" ] pub struct _ADDENW < 'a > { w : & 'a mut W , } impl < 'a > _ADDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DETACHW < 'a > { w : & 'a mut W , } impl < 'a > _DETACHW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RMWKUPW < 'a > { w : & 'a mut W , } impl < 'a > _RMWKUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SPDCONF`" ] pub enum SPDCONFW { # [ doc = "The peripheral starts in full-speed mode and performs a high-speed reset to switch to the high-speed mode if the host is high-speed capable." ] NORMAL , # [ doc = "For a better consumption, if high-speed is not needed." ] LOW_POWER , # [ doc = "Forced high speed." ] HIGH_SPEED , # [ doc = "The peripheral remains in full-speed mode whatever the host speed capability." ] FORCED_FS } impl SPDCONFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SPDCONFW :: NORMAL => 0 , SPDCONFW :: LOW_POWER => 1 , SPDCONFW :: HIGH_SPEED => 2 , SPDCONFW :: FORCED_FS => 3 } } } # [ doc = r" Proxy" ] pub struct _SPDCONFW < 'a > { w : & 'a mut W , } impl < 'a > _SPDCONFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SPDCONFW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The peripheral starts in full-speed mode and performs a high-speed reset to switch to the high-speed mode if the host is high-speed capable." ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: NORMAL ) } # [ doc = "For a better consumption, if high-speed is not needed." ] # [ inline ] pub fn low_power ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: LOW_POWER ) } # [ doc = "Forced high speed." ] # [ inline ] pub fn high_speed ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: HIGH_SPEED ) } # [ doc = "The peripheral remains in full-speed mode whatever the host speed capability." ] # [ inline ] pub fn forced_fs ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: FORCED_FS ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _LSW < 'a > { w : & 'a mut W , } impl < 'a > _LSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTJW < 'a > { w : & 'a mut W , } impl < 'a > _TSTJW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTKW < 'a > { w : & 'a mut W , } impl < 'a > _TSTKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTPCKTW < 'a > { w : & 'a mut W , } impl < 'a > _TSTPCKTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OPMODE2W < 'a > { w : & 'a mut W , } impl < 'a > _OPMODE2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:6 - USB Address" ] # [ inline ] pub fn uadd ( & self ) -> UADDR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; UADDR { bits } } # [ doc = "Bit 7 - Address Enable" ] # [ inline ] pub fn adden ( & self ) -> ADDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ADDENR { bits } } # [ doc = "Bit 8 - Detach" ] # [ inline ] pub fn detach ( & self ) -> DETACHR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DETACHR { bits } } # [ doc = "Bit 9 - Remote Wake-Up" ] # [ inline ] pub fn rmwkup ( & self ) -> RMWKUPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RMWKUPR { bits } } # [ doc = "Bits 10:11 - Mode Configuration" ] # [ inline ] pub fn spdconf ( & self ) -> SPDCONFR { SPDCONFR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Low-Speed Mode Force" ] # [ inline ] pub fn ls ( & self ) -> LSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LSR { bits } } # [ doc = "Bit 13 - Test mode J" ] # [ inline ] pub fn tstj ( & self ) -> TSTJR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTJR { bits } } # [ doc = "Bit 14 - Test mode K" ] # [ inline ] pub fn tstk ( & self ) -> TSTKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTKR { bits } } # [ doc = "Bit 15 - Test packet mode" ] # [ inline ] pub fn tstpckt ( & self ) -> TSTPCKTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTPCKTR { bits } } # [ doc = "Bit 16 - Specific Operational mode" ] # [ inline ] pub fn opmode2 ( & self ) -> OPMODE2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OPMODE2R { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100 } } # [ 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:6 - USB Address" ] # [ inline ] pub fn uadd ( & mut self ) -> _UADDW { _UADDW { w : self } } # [ doc = "Bit 7 - Address Enable" ] # [ inline ] pub fn adden ( & mut self ) -> _ADDENW { _ADDENW { w : self } } # [ doc = "Bit 8 - Detach" ] # [ inline ] pub fn detach ( & mut self ) -> _DETACHW { _DETACHW { w : self } } # [ doc = "Bit 9 - Remote Wake-Up" ] # [ inline ] pub fn rmwkup ( & mut self ) -> _RMWKUPW { _RMWKUPW { w : self } } # [ doc = "Bits 10:11 - Mode Configuration" ] # [ inline ] pub fn spdconf ( & mut self ) -> _SPDCONFW { _SPDCONFW { w : self } } # [ doc = "Bit 12 - Low-Speed Mode Force" ] # [ inline ] pub fn ls ( & mut self ) -> _LSW { _LSW { w : self } } # [ doc = "Bit 13 - Test mode J" ] # [ inline ] pub fn tstj ( & mut self ) -> _TSTJW { _TSTJW { w : self } } # [ doc = "Bit 14 - Test mode K" ] # [ inline ] pub fn tstk ( & mut self ) -> _TSTKW { _TSTKW { w : self } } # [ doc = "Bit 15 - Test packet mode" ] # [ inline ] pub fn tstpckt ( & mut self ) -> _TSTPCKTW { _TSTPCKTW { w : self } } # [ doc = "Bit 16 - Specific Operational mode" ] # [ inline ] pub fn opmode2 ( & mut self ) -> _OPMODE2W { _OPMODE2W { w : self } } } } # [ doc = "Device Global Interrupt Status Register" ] pub struct DEVISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Global Interrupt Status Register" ] pub mod devisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: DEVISR { # [ 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 SUSPR { bits : bool , } impl SUSPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MSOFR { bits : bool , } impl MSOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SOFR { bits : bool , } impl SOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EORSTR { bits : bool , } impl EORSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAKEUPR { bits : bool , } impl WAKEUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EORSMR { bits : bool , } impl EORSMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UPRSMR { bits : bool , } impl UPRSMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_0R { bits : bool , } impl PEP_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 PEP_1R { bits : bool , } impl PEP_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_2R { bits : bool , } impl PEP_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_3R { bits : bool , } impl PEP_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_4R { bits : bool , } impl PEP_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_5R { bits : bool , } impl PEP_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_6R { bits : bool , } impl PEP_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_7R { bits : bool , } impl PEP_7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_8R { bits : bool , } impl PEP_8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_9R { bits : bool , } impl PEP_9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_1R { bits : bool , } impl DMA_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_2R { bits : bool , } impl DMA_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_3R { bits : bool , } impl DMA_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_4R { bits : bool , } impl DMA_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_5R { bits : bool , } impl DMA_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_6R { bits : bool , } impl DMA_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Suspend Interrupt" ] # [ inline ] pub fn susp ( & self ) -> SUSPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSPR { bits } } # [ doc = "Bit 1 - Micro Start of Frame Interrupt" ] # [ inline ] pub fn msof ( & self ) -> MSOFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSOFR { bits } } # [ doc = "Bit 2 - Start of Frame Interrupt" ] # [ inline ] pub fn sof ( & self ) -> SOFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SOFR { bits } } # [ doc = "Bit 3 - End of Reset Interrupt" ] # [ inline ] pub fn eorst ( & self ) -> EORSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EORSTR { bits } } # [ doc = "Bit 4 - Wake-Up Interrupt" ] # [ inline ] pub fn wakeup ( & self ) -> WAKEUPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAKEUPR { bits } } # [ doc = "Bit 5 - End of Resume Interrupt" ] # [ inline ] pub fn eorsm ( & self ) -> EORSMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EORSMR { bits } } # [ doc = "Bit 6 - Upstream Resume Interrupt" ] # [ inline ] pub fn uprsm ( & self ) -> UPRSMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UPRSMR { bits } } # [ doc = "Bit 12 - Endpoint 0 Interrupt" ] # [ inline ] pub fn pep_0 ( & self ) -> PEP_0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_0R { bits } } # [ doc = "Bit 13 - Endpoint 1 Interrupt" ] # [ inline ] pub fn pep_1 ( & self ) -> PEP_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_1R { bits } } # [ doc = "Bit 14 - Endpoint 2 Interrupt" ] # [ inline ] pub fn pep_2 ( & self ) -> PEP_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_2R { bits } } # [ doc = "Bit 15 - Endpoint 3 Interrupt" ] # [ inline ] pub fn pep_3 ( & self ) -> PEP_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_3R { bits } } # [ doc = "Bit 16 - Endpoint 4 Interrupt" ] # [ inline ] pub fn pep_4 ( & self ) -> PEP_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_4R { bits } } # [ doc = "Bit 17 - Endpoint 5 Interrupt" ] # [ inline ] pub fn pep_5 ( & self ) -> PEP_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_5R { bits } } # [ doc = "Bit 18 - Endpoint 6 Interrupt" ] # [ inline ] pub fn pep_6 ( & self ) -> PEP_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_6R { bits } } # [ doc = "Bit 19 - Endpoint 7 Interrupt" ] # [ inline ] pub fn pep_7 ( & self ) -> PEP_7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_7R { bits } } # [ doc = "Bit 20 - Endpoint 8 Interrupt" ] # [ inline ] pub fn pep_8 ( & self ) -> PEP_8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_8R { bits } } # [ doc = "Bit 21 - Endpoint 9 Interrupt" ] # [ inline ] pub fn pep_9 ( & self ) -> PEP_9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_9R { bits } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt" ] # [ inline ] pub fn dma_1 ( & self ) -> DMA_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_1R { bits } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt" ] # [ inline ] pub fn dma_2 ( & self ) -> DMA_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_2R { bits } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt" ] # [ inline ] pub fn dma_3 ( & self ) -> DMA_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_3R { bits } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt" ] # [ inline ] pub fn dma_4 ( & self ) -> DMA_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_4R { bits } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt" ] # [ inline ] pub fn dma_5 ( & self ) -> DMA_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_5R { bits } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt" ] # [ inline ] pub fn dma_6 ( & self ) -> DMA_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_6R { bits } } } } # [ doc = "Device Global Interrupt Clear Register" ] pub struct DEVICR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Global Interrupt Clear Register" ] pub mod devicr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVICR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SUSPCW < 'a > { w : & 'a mut W , } impl < 'a > _SUSPCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSOFCW < 'a > { w : & 'a mut W , } impl < 'a > _MSOFCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SOFCW < 'a > { w : & 'a mut W , } impl < 'a > _SOFCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSTCW < 'a > { w : & 'a mut W , } impl < 'a > _EORSTCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPCW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSMCW < 'a > { w : & 'a mut W , } impl < 'a > _EORSMCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UPRSMCW < 'a > { w : & 'a mut W , } impl < 'a > _UPRSMCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Suspend Interrupt Clear" ] # [ inline ] pub fn suspc ( & mut self ) -> _SUSPCW { _SUSPCW { w : self } } # [ doc = "Bit 1 - Micro Start of Frame Interrupt Clear" ] # [ inline ] pub fn msofc ( & mut self ) -> _MSOFCW { _MSOFCW { w : self } } # [ doc = "Bit 2 - Start of Frame Interrupt Clear" ] # [ inline ] pub fn sofc ( & mut self ) -> _SOFCW { _SOFCW { w : self } } # [ doc = "Bit 3 - End of Reset Interrupt Clear" ] # [ inline ] pub fn eorstc ( & mut self ) -> _EORSTCW { _EORSTCW { w : self } } # [ doc = "Bit 4 - Wake-Up Interrupt Clear" ] # [ inline ] pub fn wakeupc ( & mut self ) -> _WAKEUPCW { _WAKEUPCW { w : self } } # [ doc = "Bit 5 - End of Resume Interrupt Clear" ] # [ inline ] pub fn eorsmc ( & mut self ) -> _EORSMCW { _EORSMCW { w : self } } # [ doc = "Bit 6 - Upstream Resume Interrupt Clear" ] # [ inline ] pub fn uprsmc ( & mut self ) -> _UPRSMCW { _UPRSMCW { w : self } } } } # [ doc = "Device Global Interrupt Set Register" ] pub struct DEVIFR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Global Interrupt Set Register" ] pub mod devifr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVIFR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SUSPSW < 'a > { w : & 'a mut W , } impl < 'a > _SUSPSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSOFSW < 'a > { w : & 'a mut W , } impl < 'a > _MSOFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SOFSW < 'a > { w : & 'a mut W , } impl < 'a > _SOFSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSTSW < 'a > { w : & 'a mut W , } impl < 'a > _EORSTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPSW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSMSW < 'a > { w : & 'a mut W , } impl < 'a > _EORSMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UPRSMSW < 'a > { w : & 'a mut W , } impl < 'a > _UPRSMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_1W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_2W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_3W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_4W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_5W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_6W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Suspend Interrupt Set" ] # [ inline ] pub fn susps ( & mut self ) -> _SUSPSW { _SUSPSW { w : self } } # [ doc = "Bit 1 - Micro Start of Frame Interrupt Set" ] # [ inline ] pub fn msofs ( & mut self ) -> _MSOFSW { _MSOFSW { w : self } } # [ doc = "Bit 2 - Start of Frame Interrupt Set" ] # [ inline ] pub fn sofs ( & mut self ) -> _SOFSW { _SOFSW { w : self } } # [ doc = "Bit 3 - End of Reset Interrupt Set" ] # [ inline ] pub fn eorsts ( & mut self ) -> _EORSTSW { _EORSTSW { w : self } } # [ doc = "Bit 4 - Wake-Up Interrupt Set" ] # [ inline ] pub fn wakeups ( & mut self ) -> _WAKEUPSW { _WAKEUPSW { w : self } } # [ doc = "Bit 5 - End of Resume Interrupt Set" ] # [ inline ] pub fn eorsms ( & mut self ) -> _EORSMSW { _EORSMSW { w : self } } # [ doc = "Bit 6 - Upstream Resume Interrupt Set" ] # [ inline ] pub fn uprsms ( & mut self ) -> _UPRSMSW { _UPRSMSW { w : self } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Set" ] # [ inline ] pub fn dma_1 ( & mut self ) -> _DMA_1W { _DMA_1W { w : self } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Set" ] # [ inline ] pub fn dma_2 ( & mut self ) -> _DMA_2W { _DMA_2W { w : self } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Set" ] # [ inline ] pub fn dma_3 ( & mut self ) -> _DMA_3W { _DMA_3W { w : self } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Set" ] # [ inline ] pub fn dma_4 ( & mut self ) -> _DMA_4W { _DMA_4W { w : self } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Set" ] # [ inline ] pub fn dma_5 ( & mut self ) -> _DMA_5W { _DMA_5W { w : self } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Set" ] # [ inline ] pub fn dma_6 ( & mut self ) -> _DMA_6W { _DMA_6W { w : self } } } } # [ doc = "Device Global Interrupt Mask Register" ] pub struct DEVIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Global Interrupt Mask Register" ] pub mod devimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: DEVIMR { # [ 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 SUSPER { bits : bool , } impl SUSPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MSOFER { bits : bool , } impl MSOFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SOFER { bits : bool , } impl SOFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EORSTER { bits : bool , } impl EORSTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAKEUPER { bits : bool , } impl WAKEUPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EORSMER { bits : bool , } impl EORSMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UPRSMER { bits : bool , } impl UPRSMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_0R { bits : bool , } impl PEP_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 PEP_1R { bits : bool , } impl PEP_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_2R { bits : bool , } impl PEP_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_3R { bits : bool , } impl PEP_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_4R { bits : bool , } impl PEP_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_5R { bits : bool , } impl PEP_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_6R { bits : bool , } impl PEP_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_7R { bits : bool , } impl PEP_7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_8R { bits : bool , } impl PEP_8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_9R { bits : bool , } impl PEP_9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_1R { bits : bool , } impl DMA_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_2R { bits : bool , } impl DMA_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_3R { bits : bool , } impl DMA_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_4R { bits : bool , } impl DMA_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_5R { bits : bool , } impl DMA_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_6R { bits : bool , } impl DMA_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Suspend Interrupt Mask" ] # [ inline ] pub fn suspe ( & self ) -> SUSPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSPER { bits } } # [ doc = "Bit 1 - Micro Start of Frame Interrupt Mask" ] # [ inline ] pub fn msofe ( & self ) -> MSOFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MSOFER { bits } } # [ doc = "Bit 2 - Start of Frame Interrupt Mask" ] # [ inline ] pub fn sofe ( & self ) -> SOFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SOFER { bits } } # [ doc = "Bit 3 - End of Reset Interrupt Mask" ] # [ inline ] pub fn eorste ( & self ) -> EORSTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EORSTER { bits } } # [ doc = "Bit 4 - Wake-Up Interrupt Mask" ] # [ inline ] pub fn wakeupe ( & self ) -> WAKEUPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAKEUPER { bits } } # [ doc = "Bit 5 - End of Resume Interrupt Mask" ] # [ inline ] pub fn eorsme ( & self ) -> EORSMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EORSMER { bits } } # [ doc = "Bit 6 - Upstream Resume Interrupt Mask" ] # [ inline ] pub fn uprsme ( & self ) -> UPRSMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UPRSMER { bits } } # [ doc = "Bit 12 - Endpoint 0 Interrupt Mask" ] # [ inline ] pub fn pep_0 ( & self ) -> PEP_0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_0R { bits } } # [ doc = "Bit 13 - Endpoint 1 Interrupt Mask" ] # [ inline ] pub fn pep_1 ( & self ) -> PEP_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_1R { bits } } # [ doc = "Bit 14 - Endpoint 2 Interrupt Mask" ] # [ inline ] pub fn pep_2 ( & self ) -> PEP_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_2R { bits } } # [ doc = "Bit 15 - Endpoint 3 Interrupt Mask" ] # [ inline ] pub fn pep_3 ( & self ) -> PEP_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_3R { bits } } # [ doc = "Bit 16 - Endpoint 4 Interrupt Mask" ] # [ inline ] pub fn pep_4 ( & self ) -> PEP_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_4R { bits } } # [ doc = "Bit 17 - Endpoint 5 Interrupt Mask" ] # [ inline ] pub fn pep_5 ( & self ) -> PEP_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_5R { bits } } # [ doc = "Bit 18 - Endpoint 6 Interrupt Mask" ] # [ inline ] pub fn pep_6 ( & self ) -> PEP_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_6R { bits } } # [ doc = "Bit 19 - Endpoint 7 Interrupt Mask" ] # [ inline ] pub fn pep_7 ( & self ) -> PEP_7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_7R { bits } } # [ doc = "Bit 20 - Endpoint 8 Interrupt Mask" ] # [ inline ] pub fn pep_8 ( & self ) -> PEP_8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_8R { bits } } # [ doc = "Bit 21 - Endpoint 9 Interrupt Mask" ] # [ inline ] pub fn pep_9 ( & self ) -> PEP_9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_9R { bits } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Mask" ] # [ inline ] pub fn dma_1 ( & self ) -> DMA_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_1R { bits } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Mask" ] # [ inline ] pub fn dma_2 ( & self ) -> DMA_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_2R { bits } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Mask" ] # [ inline ] pub fn dma_3 ( & self ) -> DMA_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_3R { bits } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Mask" ] # [ inline ] pub fn dma_4 ( & self ) -> DMA_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_4R { bits } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Mask" ] # [ inline ] pub fn dma_5 ( & self ) -> DMA_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_5R { bits } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Mask" ] # [ inline ] pub fn dma_6 ( & self ) -> DMA_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_6R { bits } } } } # [ doc = "Device Global Interrupt Disable Register" ] pub struct DEVIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Global Interrupt Disable Register" ] pub mod devidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SUSPECW < 'a > { w : & 'a mut W , } impl < 'a > _SUSPECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSOFECW < 'a > { w : & 'a mut W , } impl < 'a > _MSOFECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SOFECW < 'a > { w : & 'a mut W , } impl < 'a > _SOFECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSTECW < 'a > { w : & 'a mut W , } impl < 'a > _EORSTECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPECW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSMECW < 'a > { w : & 'a mut W , } impl < 'a > _EORSMECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UPRSMECW < 'a > { w : & 'a mut W , } impl < 'a > _UPRSMECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_0W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_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 = 12 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _PEP_1W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_2W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_3W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_4W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_5W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_6W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_7W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_8W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_9W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_1W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_2W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_3W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_4W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_5W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_6W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Suspend Interrupt Disable" ] # [ inline ] pub fn suspec ( & mut self ) -> _SUSPECW { _SUSPECW { w : self } } # [ doc = "Bit 1 - Micro Start of Frame Interrupt Disable" ] # [ inline ] pub fn msofec ( & mut self ) -> _MSOFECW { _MSOFECW { w : self } } # [ doc = "Bit 2 - Start of Frame Interrupt Disable" ] # [ inline ] pub fn sofec ( & mut self ) -> _SOFECW { _SOFECW { w : self } } # [ doc = "Bit 3 - End of Reset Interrupt Disable" ] # [ inline ] pub fn eorstec ( & mut self ) -> _EORSTECW { _EORSTECW { w : self } } # [ doc = "Bit 4 - Wake-Up Interrupt Disable" ] # [ inline ] pub fn wakeupec ( & mut self ) -> _WAKEUPECW { _WAKEUPECW { w : self } } # [ doc = "Bit 5 - End of Resume Interrupt Disable" ] # [ inline ] pub fn eorsmec ( & mut self ) -> _EORSMECW { _EORSMECW { w : self } } # [ doc = "Bit 6 - Upstream Resume Interrupt Disable" ] # [ inline ] pub fn uprsmec ( & mut self ) -> _UPRSMECW { _UPRSMECW { w : self } } # [ doc = "Bit 12 - Endpoint 0 Interrupt Disable" ] # [ inline ] pub fn pep_0 ( & mut self ) -> _PEP_0W { _PEP_0W { w : self } } # [ doc = "Bit 13 - Endpoint 1 Interrupt Disable" ] # [ inline ] pub fn pep_1 ( & mut self ) -> _PEP_1W { _PEP_1W { w : self } } # [ doc = "Bit 14 - Endpoint 2 Interrupt Disable" ] # [ inline ] pub fn pep_2 ( & mut self ) -> _PEP_2W { _PEP_2W { w : self } } # [ doc = "Bit 15 - Endpoint 3 Interrupt Disable" ] # [ inline ] pub fn pep_3 ( & mut self ) -> _PEP_3W { _PEP_3W { w : self } } # [ doc = "Bit 16 - Endpoint 4 Interrupt Disable" ] # [ inline ] pub fn pep_4 ( & mut self ) -> _PEP_4W { _PEP_4W { w : self } } # [ doc = "Bit 17 - Endpoint 5 Interrupt Disable" ] # [ inline ] pub fn pep_5 ( & mut self ) -> _PEP_5W { _PEP_5W { w : self } } # [ doc = "Bit 18 - Endpoint 6 Interrupt Disable" ] # [ inline ] pub fn pep_6 ( & mut self ) -> _PEP_6W { _PEP_6W { w : self } } # [ doc = "Bit 19 - Endpoint 7 Interrupt Disable" ] # [ inline ] pub fn pep_7 ( & mut self ) -> _PEP_7W { _PEP_7W { w : self } } # [ doc = "Bit 20 - Endpoint 8 Interrupt Disable" ] # [ inline ] pub fn pep_8 ( & mut self ) -> _PEP_8W { _PEP_8W { w : self } } # [ doc = "Bit 21 - Endpoint 9 Interrupt Disable" ] # [ inline ] pub fn pep_9 ( & mut self ) -> _PEP_9W { _PEP_9W { w : self } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Disable" ] # [ inline ] pub fn dma_1 ( & mut self ) -> _DMA_1W { _DMA_1W { w : self } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Disable" ] # [ inline ] pub fn dma_2 ( & mut self ) -> _DMA_2W { _DMA_2W { w : self } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Disable" ] # [ inline ] pub fn dma_3 ( & mut self ) -> _DMA_3W { _DMA_3W { w : self } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Disable" ] # [ inline ] pub fn dma_4 ( & mut self ) -> _DMA_4W { _DMA_4W { w : self } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Disable" ] # [ inline ] pub fn dma_5 ( & mut self ) -> _DMA_5W { _DMA_5W { w : self } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Disable" ] # [ inline ] pub fn dma_6 ( & mut self ) -> _DMA_6W { _DMA_6W { w : self } } } } # [ doc = "Device Global Interrupt Enable Register" ] pub struct DEVIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Global Interrupt Enable Register" ] pub mod devier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _SUSPESW < 'a > { w : & 'a mut W , } impl < 'a > _SUSPESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MSOFESW < 'a > { w : & 'a mut W , } impl < 'a > _MSOFESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SOFESW < 'a > { w : & 'a mut W , } impl < 'a > _SOFESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSTESW < 'a > { w : & 'a mut W , } impl < 'a > _EORSTESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPESW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EORSMESW < 'a > { w : & 'a mut W , } impl < 'a > _EORSMESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UPRSMESW < 'a > { w : & 'a mut W , } impl < 'a > _UPRSMESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_0W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_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 = 12 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _PEP_1W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_2W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_3W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_4W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_5W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_6W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_7W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_8W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_9W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_1W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_2W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_3W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_4W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_5W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_6W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Suspend Interrupt Enable" ] # [ inline ] pub fn suspes ( & mut self ) -> _SUSPESW { _SUSPESW { w : self } } # [ doc = "Bit 1 - Micro Start of Frame Interrupt Enable" ] # [ inline ] pub fn msofes ( & mut self ) -> _MSOFESW { _MSOFESW { w : self } } # [ doc = "Bit 2 - Start of Frame Interrupt Enable" ] # [ inline ] pub fn sofes ( & mut self ) -> _SOFESW { _SOFESW { w : self } } # [ doc = "Bit 3 - End of Reset Interrupt Enable" ] # [ inline ] pub fn eorstes ( & mut self ) -> _EORSTESW { _EORSTESW { w : self } } # [ doc = "Bit 4 - Wake-Up Interrupt Enable" ] # [ inline ] pub fn wakeupes ( & mut self ) -> _WAKEUPESW { _WAKEUPESW { w : self } } # [ doc = "Bit 5 - End of Resume Interrupt Enable" ] # [ inline ] pub fn eorsmes ( & mut self ) -> _EORSMESW { _EORSMESW { w : self } } # [ doc = "Bit 6 - Upstream Resume Interrupt Enable" ] # [ inline ] pub fn uprsmes ( & mut self ) -> _UPRSMESW { _UPRSMESW { w : self } } # [ doc = "Bit 12 - Endpoint 0 Interrupt Enable" ] # [ inline ] pub fn pep_0 ( & mut self ) -> _PEP_0W { _PEP_0W { w : self } } # [ doc = "Bit 13 - Endpoint 1 Interrupt Enable" ] # [ inline ] pub fn pep_1 ( & mut self ) -> _PEP_1W { _PEP_1W { w : self } } # [ doc = "Bit 14 - Endpoint 2 Interrupt Enable" ] # [ inline ] pub fn pep_2 ( & mut self ) -> _PEP_2W { _PEP_2W { w : self } } # [ doc = "Bit 15 - Endpoint 3 Interrupt Enable" ] # [ inline ] pub fn pep_3 ( & mut self ) -> _PEP_3W { _PEP_3W { w : self } } # [ doc = "Bit 16 - Endpoint 4 Interrupt Enable" ] # [ inline ] pub fn pep_4 ( & mut self ) -> _PEP_4W { _PEP_4W { w : self } } # [ doc = "Bit 17 - Endpoint 5 Interrupt Enable" ] # [ inline ] pub fn pep_5 ( & mut self ) -> _PEP_5W { _PEP_5W { w : self } } # [ doc = "Bit 18 - Endpoint 6 Interrupt Enable" ] # [ inline ] pub fn pep_6 ( & mut self ) -> _PEP_6W { _PEP_6W { w : self } } # [ doc = "Bit 19 - Endpoint 7 Interrupt Enable" ] # [ inline ] pub fn pep_7 ( & mut self ) -> _PEP_7W { _PEP_7W { w : self } } # [ doc = "Bit 20 - Endpoint 8 Interrupt Enable" ] # [ inline ] pub fn pep_8 ( & mut self ) -> _PEP_8W { _PEP_8W { w : self } } # [ doc = "Bit 21 - Endpoint 9 Interrupt Enable" ] # [ inline ] pub fn pep_9 ( & mut self ) -> _PEP_9W { _PEP_9W { w : self } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Enable" ] # [ inline ] pub fn dma_1 ( & mut self ) -> _DMA_1W { _DMA_1W { w : self } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Enable" ] # [ inline ] pub fn dma_2 ( & mut self ) -> _DMA_2W { _DMA_2W { w : self } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Enable" ] # [ inline ] pub fn dma_3 ( & mut self ) -> _DMA_3W { _DMA_3W { w : self } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Enable" ] # [ inline ] pub fn dma_4 ( & mut self ) -> _DMA_4W { _DMA_4W { w : self } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Enable" ] # [ inline ] pub fn dma_5 ( & mut self ) -> _DMA_5W { _DMA_5W { w : self } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Enable" ] # [ inline ] pub fn dma_6 ( & mut self ) -> _DMA_6W { _DMA_6W { w : self } } } } # [ doc = "Device Endpoint Register" ] pub struct DEVEPT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Register" ] pub mod devept { # [ 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 :: DEVEPT { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 EPEN0R { bits : bool , } impl EPEN0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN1R { bits : bool , } impl EPEN1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN2R { bits : bool , } impl EPEN2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN3R { bits : bool , } impl EPEN3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN4R { bits : bool , } impl EPEN4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN5R { bits : bool , } impl EPEN5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN6R { bits : bool , } impl EPEN6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN7R { bits : bool , } impl EPEN7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPEN8R { bits : bool , } impl EPEN8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST0R { bits : bool , } impl EPRST0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST1R { bits : bool , } impl EPRST1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST2R { bits : bool , } impl EPRST2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST3R { bits : bool , } impl EPRST3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST4R { bits : bool , } impl EPRST4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST5R { bits : bool , } impl EPRST5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST6R { bits : bool , } impl EPRST6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST7R { bits : bool , } impl EPRST7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPRST8R { bits : bool , } impl EPRST8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _EPEN0W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN1W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN2W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN3W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN4W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN5W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN6W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN7W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPEN8W < 'a > { w : & 'a mut W , } impl < 'a > _EPEN8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST0W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST1W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST2W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST3W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST4W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST5W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST6W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST7W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPRST8W < 'a > { w : & 'a mut W , } impl < 'a > _EPRST8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Endpoint 0 Enable" ] # [ inline ] pub fn epen0 ( & self ) -> EPEN0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN0R { bits } } # [ doc = "Bit 1 - Endpoint 1 Enable" ] # [ inline ] pub fn epen1 ( & self ) -> EPEN1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN1R { bits } } # [ doc = "Bit 2 - Endpoint 2 Enable" ] # [ inline ] pub fn epen2 ( & self ) -> EPEN2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN2R { bits } } # [ doc = "Bit 3 - Endpoint 3 Enable" ] # [ inline ] pub fn epen3 ( & self ) -> EPEN3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN3R { bits } } # [ doc = "Bit 4 - Endpoint 4 Enable" ] # [ inline ] pub fn epen4 ( & self ) -> EPEN4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN4R { bits } } # [ doc = "Bit 5 - Endpoint 5 Enable" ] # [ inline ] pub fn epen5 ( & self ) -> EPEN5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN5R { bits } } # [ doc = "Bit 6 - Endpoint 6 Enable" ] # [ inline ] pub fn epen6 ( & self ) -> EPEN6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN6R { bits } } # [ doc = "Bit 7 - Endpoint 7 Enable" ] # [ inline ] pub fn epen7 ( & self ) -> EPEN7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN7R { bits } } # [ doc = "Bit 8 - Endpoint 8 Enable" ] # [ inline ] pub fn epen8 ( & self ) -> EPEN8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPEN8R { bits } } # [ doc = "Bit 16 - Endpoint 0 Reset" ] # [ inline ] pub fn eprst0 ( & self ) -> EPRST0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST0R { bits } } # [ doc = "Bit 17 - Endpoint 1 Reset" ] # [ inline ] pub fn eprst1 ( & self ) -> EPRST1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST1R { bits } } # [ doc = "Bit 18 - Endpoint 2 Reset" ] # [ inline ] pub fn eprst2 ( & self ) -> EPRST2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST2R { bits } } # [ doc = "Bit 19 - Endpoint 3 Reset" ] # [ inline ] pub fn eprst3 ( & self ) -> EPRST3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST3R { bits } } # [ doc = "Bit 20 - Endpoint 4 Reset" ] # [ inline ] pub fn eprst4 ( & self ) -> EPRST4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST4R { bits } } # [ doc = "Bit 21 - Endpoint 5 Reset" ] # [ inline ] pub fn eprst5 ( & self ) -> EPRST5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST5R { bits } } # [ doc = "Bit 22 - Endpoint 6 Reset" ] # [ inline ] pub fn eprst6 ( & self ) -> EPRST6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST6R { bits } } # [ doc = "Bit 23 - Endpoint 7 Reset" ] # [ inline ] pub fn eprst7 ( & self ) -> EPRST7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST7R { bits } } # [ doc = "Bit 24 - Endpoint 8 Reset" ] # [ inline ] pub fn eprst8 ( & self ) -> EPRST8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPRST8R { 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 - Endpoint 0 Enable" ] # [ inline ] pub fn epen0 ( & mut self ) -> _EPEN0W { _EPEN0W { w : self } } # [ doc = "Bit 1 - Endpoint 1 Enable" ] # [ inline ] pub fn epen1 ( & mut self ) -> _EPEN1W { _EPEN1W { w : self } } # [ doc = "Bit 2 - Endpoint 2 Enable" ] # [ inline ] pub fn epen2 ( & mut self ) -> _EPEN2W { _EPEN2W { w : self } } # [ doc = "Bit 3 - Endpoint 3 Enable" ] # [ inline ] pub fn epen3 ( & mut self ) -> _EPEN3W { _EPEN3W { w : self } } # [ doc = "Bit 4 - Endpoint 4 Enable" ] # [ inline ] pub fn epen4 ( & mut self ) -> _EPEN4W { _EPEN4W { w : self } } # [ doc = "Bit 5 - Endpoint 5 Enable" ] # [ inline ] pub fn epen5 ( & mut self ) -> _EPEN5W { _EPEN5W { w : self } } # [ doc = "Bit 6 - Endpoint 6 Enable" ] # [ inline ] pub fn epen6 ( & mut self ) -> _EPEN6W { _EPEN6W { w : self } } # [ doc = "Bit 7 - Endpoint 7 Enable" ] # [ inline ] pub fn epen7 ( & mut self ) -> _EPEN7W { _EPEN7W { w : self } } # [ doc = "Bit 8 - Endpoint 8 Enable" ] # [ inline ] pub fn epen8 ( & mut self ) -> _EPEN8W { _EPEN8W { w : self } } # [ doc = "Bit 16 - Endpoint 0 Reset" ] # [ inline ] pub fn eprst0 ( & mut self ) -> _EPRST0W { _EPRST0W { w : self } } # [ doc = "Bit 17 - Endpoint 1 Reset" ] # [ inline ] pub fn eprst1 ( & mut self ) -> _EPRST1W { _EPRST1W { w : self } } # [ doc = "Bit 18 - Endpoint 2 Reset" ] # [ inline ] pub fn eprst2 ( & mut self ) -> _EPRST2W { _EPRST2W { w : self } } # [ doc = "Bit 19 - Endpoint 3 Reset" ] # [ inline ] pub fn eprst3 ( & mut self ) -> _EPRST3W { _EPRST3W { w : self } } # [ doc = "Bit 20 - Endpoint 4 Reset" ] # [ inline ] pub fn eprst4 ( & mut self ) -> _EPRST4W { _EPRST4W { w : self } } # [ doc = "Bit 21 - Endpoint 5 Reset" ] # [ inline ] pub fn eprst5 ( & mut self ) -> _EPRST5W { _EPRST5W { w : self } } # [ doc = "Bit 22 - Endpoint 6 Reset" ] # [ inline ] pub fn eprst6 ( & mut self ) -> _EPRST6W { _EPRST6W { w : self } } # [ doc = "Bit 23 - Endpoint 7 Reset" ] # [ inline ] pub fn eprst7 ( & mut self ) -> _EPRST7W { _EPRST7W { w : self } } # [ doc = "Bit 24 - Endpoint 8 Reset" ] # [ inline ] pub fn eprst8 ( & mut self ) -> _EPRST8W { _EPRST8W { w : self } } } } # [ doc = "Device Frame Number Register" ] pub struct DEVFNUM { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Frame Number Register" ] pub mod devfnum { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: DEVFNUM { # [ 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 MFNUMR { bits : u8 , } impl MFNUMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FNUMR { bits : u16 , } impl FNUMR { # [ 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 FNCERRR { bits : bool , } impl FNCERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:2 - Micro Frame Number" ] # [ inline ] pub fn mfnum ( & self ) -> MFNUMR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MFNUMR { bits } } # [ doc = "Bits 3:13 - Frame Number" ] # [ inline ] pub fn fnum ( & self ) -> FNUMR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; FNUMR { bits } } # [ doc = "Bit 15 - Frame Number CRC Error" ] # [ inline ] pub fn fncerr ( & self ) -> FNCERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FNCERRR { bits } } } } # [ doc = "Device Endpoint Configuration Register (n = 0)" ] pub struct DEVEPTCFG { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Configuration Register (n = 0)" ] pub mod deveptcfg { # [ 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 :: DEVEPTCFG { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 ALLOCR { bits : bool , } impl ALLOCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EPBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EPBKR { # [ doc = "Single-bank endpoint" ] _1_BANK , # [ doc = "Double-bank endpoint" ] _2_BANK , # [ doc = "Triple-bank endpoint" ] _3_BANK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EPBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EPBKR :: _1_BANK => 0 , EPBKR :: _2_BANK => 0x01 , EPBKR :: _3_BANK => 0x02 , EPBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EPBKR { match value { 0 => EPBKR :: _1_BANK , 1 => EPBKR :: _2_BANK , 2 => EPBKR :: _3_BANK , i => EPBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1_BANK`" ] # [ inline ] pub fn is_1_bank ( & self ) -> bool { * self == EPBKR :: _1_BANK } # [ doc = "Checks if the value of the field is `_2_BANK`" ] # [ inline ] pub fn is_2_bank ( & self ) -> bool { * self == EPBKR :: _2_BANK } # [ doc = "Checks if the value of the field is `_3_BANK`" ] # [ inline ] pub fn is_3_bank ( & self ) -> bool { * self == EPBKR :: _3_BANK } } # [ doc = "Possible values of the field `EPSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EPSIZER { # [ doc = "8 bytes" ] _8_BYTE , # [ doc = "16 bytes" ] _16_BYTE , # [ doc = "32 bytes" ] _32_BYTE , # [ doc = "64 bytes" ] _64_BYTE , # [ doc = "128 bytes" ] _128_BYTE , # [ doc = "256 bytes" ] _256_BYTE , # [ doc = "512 bytes" ] _512_BYTE , # [ doc = "1024 bytes" ] _1024_BYTE } impl EPSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EPSIZER :: _8_BYTE => 0 , EPSIZER :: _16_BYTE => 0x01 , EPSIZER :: _32_BYTE => 0x02 , EPSIZER :: _64_BYTE => 0x03 , EPSIZER :: _128_BYTE => 0x04 , EPSIZER :: _256_BYTE => 0x05 , EPSIZER :: _512_BYTE => 0x06 , EPSIZER :: _1024_BYTE => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EPSIZER { match value { 0 => EPSIZER :: _8_BYTE , 1 => EPSIZER :: _16_BYTE , 2 => EPSIZER :: _32_BYTE , 3 => EPSIZER :: _64_BYTE , 4 => EPSIZER :: _128_BYTE , 5 => EPSIZER :: _256_BYTE , 6 => EPSIZER :: _512_BYTE , 7 => EPSIZER :: _1024_BYTE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_8_BYTE`" ] # [ inline ] pub fn is_8_byte ( & self ) -> bool { * self == EPSIZER :: _8_BYTE } # [ doc = "Checks if the value of the field is `_16_BYTE`" ] # [ inline ] pub fn is_16_byte ( & self ) -> bool { * self == EPSIZER :: _16_BYTE } # [ doc = "Checks if the value of the field is `_32_BYTE`" ] # [ inline ] pub fn is_32_byte ( & self ) -> bool { * self == EPSIZER :: _32_BYTE } # [ doc = "Checks if the value of the field is `_64_BYTE`" ] # [ inline ] pub fn is_64_byte ( & self ) -> bool { * self == EPSIZER :: _64_BYTE } # [ doc = "Checks if the value of the field is `_128_BYTE`" ] # [ inline ] pub fn is_128_byte ( & self ) -> bool { * self == EPSIZER :: _128_BYTE } # [ doc = "Checks if the value of the field is `_256_BYTE`" ] # [ inline ] pub fn is_256_byte ( & self ) -> bool { * self == EPSIZER :: _256_BYTE } # [ doc = "Checks if the value of the field is `_512_BYTE`" ] # [ inline ] pub fn is_512_byte ( & self ) -> bool { * self == EPSIZER :: _512_BYTE } # [ doc = "Checks if the value of the field is `_1024_BYTE`" ] # [ inline ] pub fn is_1024_byte ( & self ) -> bool { * self == EPSIZER :: _1024_BYTE } } # [ doc = "Possible values of the field `EPDIR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EPDIRR { # [ doc = "The endpoint direction is OUT." ] OUT , # [ doc = "The endpoint direction is IN (nor for control endpoints)." ] IN } impl EPDIRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { EPDIRR :: OUT => false , EPDIRR :: IN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> EPDIRR { match value { false => EPDIRR :: OUT , true => EPDIRR :: IN , } } # [ doc = "Checks if the value of the field is `OUT`" ] # [ inline ] pub fn is_out ( & self ) -> bool { * self == EPDIRR :: OUT } # [ doc = "Checks if the value of the field is `IN`" ] # [ inline ] pub fn is_in_ ( & self ) -> bool { * self == EPDIRR :: IN } } # [ doc = r" Value of the field" ] pub struct AUTOSWR { bits : bool , } impl AUTOSWR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `EPTYPE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EPTYPER { # [ doc = "Control" ] CTRL , # [ doc = "Isochronous" ] ISO , # [ doc = "Bulk" ] BLK , # [ doc = "Interrupt" ] INTRPT } impl EPTYPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EPTYPER :: CTRL => 0 , EPTYPER :: ISO => 0x01 , EPTYPER :: BLK => 0x02 , EPTYPER :: INTRPT => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EPTYPER { match value { 0 => EPTYPER :: CTRL , 1 => EPTYPER :: ISO , 2 => EPTYPER :: BLK , 3 => EPTYPER :: INTRPT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `CTRL`" ] # [ inline ] pub fn is_ctrl ( & self ) -> bool { * self == EPTYPER :: CTRL } # [ doc = "Checks if the value of the field is `ISO`" ] # [ inline ] pub fn is_iso ( & self ) -> bool { * self == EPTYPER :: ISO } # [ doc = "Checks if the value of the field is `BLK`" ] # [ inline ] pub fn is_blk ( & self ) -> bool { * self == EPTYPER :: BLK } # [ doc = "Checks if the value of the field is `INTRPT`" ] # [ inline ] pub fn is_intrpt ( & self ) -> bool { * self == EPTYPER :: INTRPT } } # [ doc = "Possible values of the field `NBTRANS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBTRANSR { # [ doc = "reserved to endpoint that does not have the high-bandwidth isochronous capability." ] _0_TRANS , # [ doc = "default value: one transaction per micro-frame." ] _1_TRANS , # [ doc = "2 transactions per micro-frame. This endpoint should be configured as double-bank." ] _2_TRANS , # [ doc = "3 transactions per micro-frame. This endpoint should be configured as triple-bank." ] _3_TRANS } impl NBTRANSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBTRANSR :: _0_TRANS => 0 , NBTRANSR :: _1_TRANS => 0x01 , NBTRANSR :: _2_TRANS => 0x02 , NBTRANSR :: _3_TRANS => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBTRANSR { match value { 0 => NBTRANSR :: _0_TRANS , 1 => NBTRANSR :: _1_TRANS , 2 => NBTRANSR :: _2_TRANS , 3 => NBTRANSR :: _3_TRANS , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_0_TRANS`" ] # [ inline ] pub fn is_0_trans ( & self ) -> bool { * self == NBTRANSR :: _0_TRANS } # [ doc = "Checks if the value of the field is `_1_TRANS`" ] # [ inline ] pub fn is_1_trans ( & self ) -> bool { * self == NBTRANSR :: _1_TRANS } # [ doc = "Checks if the value of the field is `_2_TRANS`" ] # [ inline ] pub fn is_2_trans ( & self ) -> bool { * self == NBTRANSR :: _2_TRANS } # [ doc = "Checks if the value of the field is `_3_TRANS`" ] # [ inline ] pub fn is_3_trans ( & self ) -> bool { * self == NBTRANSR :: _3_TRANS } } # [ doc = r" Proxy" ] pub struct _ALLOCW < 'a > { w : & 'a mut W , } impl < 'a > _ALLOCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EPBK`" ] pub enum EPBKW { # [ doc = "Single-bank endpoint" ] _1_BANK , # [ doc = "Double-bank endpoint" ] _2_BANK , # [ doc = "Triple-bank endpoint" ] _3_BANK } impl EPBKW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EPBKW :: _1_BANK => 0 , EPBKW :: _2_BANK => 1 , EPBKW :: _3_BANK => 2 } } } # [ doc = r" Proxy" ] pub struct _EPBKW < 'a > { w : & 'a mut W , } impl < 'a > _EPBKW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EPBKW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Single-bank endpoint" ] # [ inline ] pub fn _1_bank ( self ) -> & 'a mut W { self . variant ( EPBKW :: _1_BANK ) } # [ doc = "Double-bank endpoint" ] # [ inline ] pub fn _2_bank ( self ) -> & 'a mut W { self . variant ( EPBKW :: _2_BANK ) } # [ doc = "Triple-bank endpoint" ] # [ inline ] pub fn _3_bank ( self ) -> & 'a mut W { self . variant ( EPBKW :: _3_BANK ) } # [ 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 = "Values that can be written to the field `EPSIZE`" ] pub enum EPSIZEW { # [ doc = "8 bytes" ] _8_BYTE , # [ doc = "16 bytes" ] _16_BYTE , # [ doc = "32 bytes" ] _32_BYTE , # [ doc = "64 bytes" ] _64_BYTE , # [ doc = "128 bytes" ] _128_BYTE , # [ doc = "256 bytes" ] _256_BYTE , # [ doc = "512 bytes" ] _512_BYTE , # [ doc = "1024 bytes" ] _1024_BYTE } impl EPSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EPSIZEW :: _8_BYTE => 0 , EPSIZEW :: _16_BYTE => 1 , EPSIZEW :: _32_BYTE => 2 , EPSIZEW :: _64_BYTE => 3 , EPSIZEW :: _128_BYTE => 4 , EPSIZEW :: _256_BYTE => 5 , EPSIZEW :: _512_BYTE => 6 , EPSIZEW :: _1024_BYTE => 7 } } } # [ doc = r" Proxy" ] pub struct _EPSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _EPSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EPSIZEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "8 bytes" ] # [ inline ] pub fn _8_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _8_BYTE ) } # [ doc = "16 bytes" ] # [ inline ] pub fn _16_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _16_BYTE ) } # [ doc = "32 bytes" ] # [ inline ] pub fn _32_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _32_BYTE ) } # [ doc = "64 bytes" ] # [ inline ] pub fn _64_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _64_BYTE ) } # [ doc = "128 bytes" ] # [ inline ] pub fn _128_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _128_BYTE ) } # [ doc = "256 bytes" ] # [ inline ] pub fn _256_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _256_BYTE ) } # [ doc = "512 bytes" ] # [ inline ] pub fn _512_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _512_BYTE ) } # [ doc = "1024 bytes" ] # [ inline ] pub fn _1024_byte ( self ) -> & 'a mut W { self . variant ( EPSIZEW :: _1024_BYTE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `EPDIR`" ] pub enum EPDIRW { # [ doc = "The endpoint direction is OUT." ] OUT , # [ doc = "The endpoint direction is IN (nor for control endpoints)." ] IN } impl EPDIRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { EPDIRW :: OUT => false , EPDIRW :: IN => true } } } # [ doc = r" Proxy" ] pub struct _EPDIRW < 'a > { w : & 'a mut W , } impl < 'a > _EPDIRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EPDIRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The endpoint direction is OUT." ] # [ inline ] pub fn out ( self ) -> & 'a mut W { self . variant ( EPDIRW :: OUT ) } # [ doc = "The endpoint direction is IN (nor for control endpoints)." ] # [ inline ] pub fn in_ ( self ) -> & 'a mut W { self . variant ( EPDIRW :: IN ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AUTOSWW < 'a > { w : & 'a mut W , } impl < 'a > _AUTOSWW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EPTYPE`" ] pub enum EPTYPEW { # [ doc = "Control" ] CTRL , # [ doc = "Isochronous" ] ISO , # [ doc = "Bulk" ] BLK , # [ doc = "Interrupt" ] INTRPT } impl EPTYPEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EPTYPEW :: CTRL => 0 , EPTYPEW :: ISO => 1 , EPTYPEW :: BLK => 2 , EPTYPEW :: INTRPT => 3 } } } # [ doc = r" Proxy" ] pub struct _EPTYPEW < 'a > { w : & 'a mut W , } impl < 'a > _EPTYPEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EPTYPEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Control" ] # [ inline ] pub fn ctrl ( self ) -> & 'a mut W { self . variant ( EPTYPEW :: CTRL ) } # [ doc = "Isochronous" ] # [ inline ] pub fn iso ( self ) -> & 'a mut W { self . variant ( EPTYPEW :: ISO ) } # [ doc = "Bulk" ] # [ inline ] pub fn blk ( self ) -> & 'a mut W { self . variant ( EPTYPEW :: BLK ) } # [ doc = "Interrupt" ] # [ inline ] pub fn intrpt ( self ) -> & 'a mut W { self . variant ( EPTYPEW :: INTRPT ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `NBTRANS`" ] pub enum NBTRANSW { # [ doc = "reserved to endpoint that does not have the high-bandwidth isochronous capability." ] _0_TRANS , # [ doc = "default value: one transaction per micro-frame." ] _1_TRANS , # [ doc = "2 transactions per micro-frame. This endpoint should be configured as double-bank." ] _2_TRANS , # [ doc = "3 transactions per micro-frame. This endpoint should be configured as triple-bank." ] _3_TRANS } impl NBTRANSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { NBTRANSW :: _0_TRANS => 0 , NBTRANSW :: _1_TRANS => 1 , NBTRANSW :: _2_TRANS => 2 , NBTRANSW :: _3_TRANS => 3 } } } # [ doc = r" Proxy" ] pub struct _NBTRANSW < 'a > { w : & 'a mut W , } impl < 'a > _NBTRANSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : NBTRANSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "reserved to endpoint that does not have the high-bandwidth isochronous capability." ] # [ inline ] pub fn _0_trans ( self ) -> & 'a mut W { self . variant ( NBTRANSW :: _0_TRANS ) } # [ doc = "default value: one transaction per micro-frame." ] # [ inline ] pub fn _1_trans ( self ) -> & 'a mut W { self . variant ( NBTRANSW :: _1_TRANS ) } # [ doc = "2 transactions per micro-frame. This endpoint should be configured as double-bank." ] # [ inline ] pub fn _2_trans ( self ) -> & 'a mut W { self . variant ( NBTRANSW :: _2_TRANS ) } # [ doc = "3 transactions per micro-frame. This endpoint should be configured as triple-bank." ] # [ inline ] pub fn _3_trans ( self ) -> & 'a mut W { self . variant ( NBTRANSW :: _3_TRANS ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 1 - Endpoint Memory Allocate" ] # [ inline ] pub fn alloc ( & self ) -> ALLOCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ALLOCR { bits } } # [ doc = "Bits 2:3 - Endpoint Banks" ] # [ inline ] pub fn epbk ( & self ) -> EPBKR { EPBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:6 - Endpoint Size" ] # [ inline ] pub fn epsize ( & self ) -> EPSIZER { EPSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Endpoint Direction" ] # [ inline ] pub fn epdir ( & self ) -> EPDIRR { EPDIRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 9 - Automatic Switch" ] # [ inline ] pub fn autosw ( & self ) -> AUTOSWR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AUTOSWR { bits } } # [ doc = "Bits 11:12 - Endpoint Type" ] # [ inline ] pub fn eptype ( & self ) -> EPTYPER { EPTYPER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 13:14 - Number of transaction per microframe for isochronous endpoint" ] # [ inline ] pub fn nbtrans ( & self ) -> NBTRANSR { NBTRANSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = "Bit 1 - Endpoint Memory Allocate" ] # [ inline ] pub fn alloc ( & mut self ) -> _ALLOCW { _ALLOCW { w : self } } # [ doc = "Bits 2:3 - Endpoint Banks" ] # [ inline ] pub fn epbk ( & mut self ) -> _EPBKW { _EPBKW { w : self } } # [ doc = "Bits 4:6 - Endpoint Size" ] # [ inline ] pub fn epsize ( & mut self ) -> _EPSIZEW { _EPSIZEW { w : self } } # [ doc = "Bit 8 - Endpoint Direction" ] # [ inline ] pub fn epdir ( & mut self ) -> _EPDIRW { _EPDIRW { w : self } } # [ doc = "Bit 9 - Automatic Switch" ] # [ inline ] pub fn autosw ( & mut self ) -> _AUTOSWW { _AUTOSWW { w : self } } # [ doc = "Bits 11:12 - Endpoint Type" ] # [ inline ] pub fn eptype ( & mut self ) -> _EPTYPEW { _EPTYPEW { w : self } } # [ doc = "Bits 13:14 - Number of transaction per microframe for isochronous endpoint" ] # [ inline ] pub fn nbtrans ( & mut self ) -> _NBTRANSW { _NBTRANSW { w : self } } } } # [ doc = "Device Endpoint Status Register (n = 0)" ] pub struct DEVEPTISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Status Register (n = 0)" ] pub mod deveptisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: DEVEPTISR { # [ 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 TXINIR { bits : bool , } impl TXINIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXOUTIR { bits : bool , } impl RXOUTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSTPIR { bits : bool , } impl RXSTPIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKOUTIR { bits : bool , } impl NAKOUTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKINIR { bits : bool , } impl NAKINIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIR { bits : bool , } impl OVERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STALLEDIR { bits : bool , } impl STALLEDIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETR { bits : bool , } impl SHORTPACKETR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DTSEQ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DTSEQR { # [ doc = "Data0 toggle sequence" ] DATA0 , # [ doc = "Data1 toggle sequence" ] DATA1 , # [ doc = "Reserved for high-bandwidth isochronous endpoint" ] DATA2 , # [ doc = "Reserved for high-bandwidth isochronous endpoint" ] MDATA } impl DTSEQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DTSEQR :: DATA0 => 0 , DTSEQR :: DATA1 => 0x01 , DTSEQR :: DATA2 => 0x02 , DTSEQR :: MDATA => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DTSEQR { match value { 0 => DTSEQR :: DATA0 , 1 => DTSEQR :: DATA1 , 2 => DTSEQR :: DATA2 , 3 => DTSEQR :: MDATA , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `DATA0`" ] # [ inline ] pub fn is_data0 ( & self ) -> bool { * self == DTSEQR :: DATA0 } # [ doc = "Checks if the value of the field is `DATA1`" ] # [ inline ] pub fn is_data1 ( & self ) -> bool { * self == DTSEQR :: DATA1 } # [ doc = "Checks if the value of the field is `DATA2`" ] # [ inline ] pub fn is_data2 ( & self ) -> bool { * self == DTSEQR :: DATA2 } # [ doc = "Checks if the value of the field is `MDATA`" ] # [ inline ] pub fn is_mdata ( & self ) -> bool { * self == DTSEQR :: MDATA } } # [ doc = "Possible values of the field `NBUSYBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBUSYBKR { # [ doc = "0 busy bank (all banks free)" ] _0_BUSY , # [ doc = "1 busy bank" ] _1_BUSY , # [ doc = "2 busy banks" ] _2_BUSY , # [ doc = "3 busy banks" ] _3_BUSY } impl NBUSYBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBUSYBKR :: _0_BUSY => 0 , NBUSYBKR :: _1_BUSY => 0x01 , NBUSYBKR :: _2_BUSY => 0x02 , NBUSYBKR :: _3_BUSY => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBUSYBKR { match value { 0 => NBUSYBKR :: _0_BUSY , 1 => NBUSYBKR :: _1_BUSY , 2 => NBUSYBKR :: _2_BUSY , 3 => NBUSYBKR :: _3_BUSY , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_0_BUSY`" ] # [ inline ] pub fn is_0_busy ( & self ) -> bool { * self == NBUSYBKR :: _0_BUSY } # [ doc = "Checks if the value of the field is `_1_BUSY`" ] # [ inline ] pub fn is_1_busy ( & self ) -> bool { * self == NBUSYBKR :: _1_BUSY } # [ doc = "Checks if the value of the field is `_2_BUSY`" ] # [ inline ] pub fn is_2_busy ( & self ) -> bool { * self == NBUSYBKR :: _2_BUSY } # [ doc = "Checks if the value of the field is `_3_BUSY`" ] # [ inline ] pub fn is_3_busy ( & self ) -> bool { * self == NBUSYBKR :: _3_BUSY } } # [ doc = "Possible values of the field `CURRBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CURRBKR { # [ doc = "Current bank is bank0" ] BANK0 , # [ doc = "Current bank is bank1" ] BANK1 , # [ doc = "Current bank is bank2" ] BANK2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CURRBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CURRBKR :: BANK0 => 0 , CURRBKR :: BANK1 => 0x01 , CURRBKR :: BANK2 => 0x02 , CURRBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CURRBKR { match value { 0 => CURRBKR :: BANK0 , 1 => CURRBKR :: BANK1 , 2 => CURRBKR :: BANK2 , i => CURRBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BANK0`" ] # [ inline ] pub fn is_bank0 ( & self ) -> bool { * self == CURRBKR :: BANK0 } # [ doc = "Checks if the value of the field is `BANK1`" ] # [ inline ] pub fn is_bank1 ( & self ) -> bool { * self == CURRBKR :: BANK1 } # [ doc = "Checks if the value of the field is `BANK2`" ] # [ inline ] pub fn is_bank2 ( & self ) -> bool { * self == CURRBKR :: BANK2 } } # [ doc = r" Value of the field" ] pub struct RWALLR { bits : bool , } impl RWALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CTRLDIRR { bits : bool , } impl CTRLDIRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFGOKR { bits : bool , } impl CFGOKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BYCTR { bits : u16 , } impl BYCTR { # [ 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 = "Bit 0 - Transmitted IN Data Interrupt" ] # [ inline ] pub fn txini ( & self ) -> TXINIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXINIR { bits } } # [ doc = "Bit 1 - Received OUT Data Interrupt" ] # [ inline ] pub fn rxouti ( & self ) -> RXOUTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXOUTIR { bits } } # [ doc = "Bit 2 - Received SETUP Interrupt" ] # [ inline ] pub fn rxstpi ( & self ) -> RXSTPIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSTPIR { bits } } # [ doc = "Bit 3 - NAKed OUT Interrupt" ] # [ inline ] pub fn nakouti ( & self ) -> NAKOUTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKOUTIR { bits } } # [ doc = "Bit 4 - NAKed IN Interrupt" ] # [ inline ] pub fn nakini ( & self ) -> NAKINIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKINIR { bits } } # [ doc = "Bit 5 - Overflow Interrupt" ] # [ inline ] pub fn overfi ( & self ) -> OVERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIR { bits } } # [ doc = "Bit 6 - STALLed Interrupt" ] # [ inline ] pub fn stalledi ( & self ) -> STALLEDIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STALLEDIR { bits } } # [ doc = "Bit 7 - Short Packet Interrupt" ] # [ inline ] pub fn shortpacket ( & self ) -> SHORTPACKETR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETR { bits } } # [ doc = "Bits 8:9 - Data Toggle Sequence" ] # [ inline ] pub fn dtseq ( & self ) -> DTSEQR { DTSEQR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Busy Banks" ] # [ inline ] pub fn nbusybk ( & self ) -> NBUSYBKR { NBUSYBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Current Bank" ] # [ inline ] pub fn currbk ( & self ) -> CURRBKR { CURRBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Read-write Allowed" ] # [ inline ] pub fn rwall ( & self ) -> RWALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RWALLR { bits } } # [ doc = "Bit 17 - Control Direction" ] # [ inline ] pub fn ctrldir ( & self ) -> CTRLDIRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CTRLDIRR { bits } } # [ doc = "Bit 18 - Configuration OK Status" ] # [ inline ] pub fn cfgok ( & self ) -> CFGOKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFGOKR { bits } } # [ doc = "Bits 20:30 - Byte Count" ] # [ inline ] pub fn byct ( & self ) -> BYCTR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BYCTR { bits } } } } # [ doc = "Device Endpoint Status Register (n = 0)" ] pub struct DEVEPTISR0_ISOENPT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Status Register (n = 0)" ] pub mod deveptisr0_isoenpt { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: DEVEPTISR0_ISOENPT { # [ 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 TXINIR { bits : bool , } impl TXINIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXOUTIR { bits : bool , } impl RXOUTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDERFIR { bits : bool , } impl UNDERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HBISOINERRIR { bits : bool , } impl HBISOINERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HBISOFLUSHIR { bits : bool , } impl HBISOFLUSHIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIR { bits : bool , } impl OVERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CRCERRIR { bits : bool , } impl CRCERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETR { bits : bool , } impl SHORTPACKETR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DTSEQ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DTSEQR { # [ doc = "Data0 toggle sequence" ] DATA0 , # [ doc = "Data1 toggle sequence" ] DATA1 , # [ doc = "Data2 toggle sequence (for high-bandwidth isochronous endpoint)" ] DATA2 , # [ doc = "MData toggle sequence (for high-bandwidth isochronous endpoint)" ] MDATA } impl DTSEQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DTSEQR :: DATA0 => 0 , DTSEQR :: DATA1 => 0x01 , DTSEQR :: DATA2 => 0x02 , DTSEQR :: MDATA => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DTSEQR { match value { 0 => DTSEQR :: DATA0 , 1 => DTSEQR :: DATA1 , 2 => DTSEQR :: DATA2 , 3 => DTSEQR :: MDATA , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `DATA0`" ] # [ inline ] pub fn is_data0 ( & self ) -> bool { * self == DTSEQR :: DATA0 } # [ doc = "Checks if the value of the field is `DATA1`" ] # [ inline ] pub fn is_data1 ( & self ) -> bool { * self == DTSEQR :: DATA1 } # [ doc = "Checks if the value of the field is `DATA2`" ] # [ inline ] pub fn is_data2 ( & self ) -> bool { * self == DTSEQR :: DATA2 } # [ doc = "Checks if the value of the field is `MDATA`" ] # [ inline ] pub fn is_mdata ( & self ) -> bool { * self == DTSEQR :: MDATA } } # [ doc = r" Value of the field" ] pub struct ERRORTRANSR { bits : bool , } impl ERRORTRANSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `NBUSYBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBUSYBKR { # [ doc = "0 busy bank (all banks free)" ] _0_BUSY , # [ doc = "1 busy bank" ] _1_BUSY , # [ doc = "2 busy banks" ] _2_BUSY , # [ doc = "3 busy banks" ] _3_BUSY } impl NBUSYBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBUSYBKR :: _0_BUSY => 0 , NBUSYBKR :: _1_BUSY => 0x01 , NBUSYBKR :: _2_BUSY => 0x02 , NBUSYBKR :: _3_BUSY => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBUSYBKR { match value { 0 => NBUSYBKR :: _0_BUSY , 1 => NBUSYBKR :: _1_BUSY , 2 => NBUSYBKR :: _2_BUSY , 3 => NBUSYBKR :: _3_BUSY , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_0_BUSY`" ] # [ inline ] pub fn is_0_busy ( & self ) -> bool { * self == NBUSYBKR :: _0_BUSY } # [ doc = "Checks if the value of the field is `_1_BUSY`" ] # [ inline ] pub fn is_1_busy ( & self ) -> bool { * self == NBUSYBKR :: _1_BUSY } # [ doc = "Checks if the value of the field is `_2_BUSY`" ] # [ inline ] pub fn is_2_busy ( & self ) -> bool { * self == NBUSYBKR :: _2_BUSY } # [ doc = "Checks if the value of the field is `_3_BUSY`" ] # [ inline ] pub fn is_3_busy ( & self ) -> bool { * self == NBUSYBKR :: _3_BUSY } } # [ doc = "Possible values of the field `CURRBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CURRBKR { # [ doc = "Current bank is bank0" ] BANK0 , # [ doc = "Current bank is bank1" ] BANK1 , # [ doc = "Current bank is bank2" ] BANK2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CURRBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CURRBKR :: BANK0 => 0 , CURRBKR :: BANK1 => 0x01 , CURRBKR :: BANK2 => 0x02 , CURRBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CURRBKR { match value { 0 => CURRBKR :: BANK0 , 1 => CURRBKR :: BANK1 , 2 => CURRBKR :: BANK2 , i => CURRBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BANK0`" ] # [ inline ] pub fn is_bank0 ( & self ) -> bool { * self == CURRBKR :: BANK0 } # [ doc = "Checks if the value of the field is `BANK1`" ] # [ inline ] pub fn is_bank1 ( & self ) -> bool { * self == CURRBKR :: BANK1 } # [ doc = "Checks if the value of the field is `BANK2`" ] # [ inline ] pub fn is_bank2 ( & self ) -> bool { * self == CURRBKR :: BANK2 } } # [ doc = r" Value of the field" ] pub struct RWALLR { bits : bool , } impl RWALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFGOKR { bits : bool , } impl CFGOKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BYCTR { bits : u16 , } impl BYCTR { # [ 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 = "Bit 0 - Transmitted IN Data Interrupt" ] # [ inline ] pub fn txini ( & self ) -> TXINIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXINIR { bits } } # [ doc = "Bit 1 - Received OUT Data Interrupt" ] # [ inline ] pub fn rxouti ( & self ) -> RXOUTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXOUTIR { bits } } # [ doc = "Bit 2 - Underflow Interrupt" ] # [ inline ] pub fn underfi ( & self ) -> UNDERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDERFIR { bits } } # [ doc = "Bit 3 - High Bandwidth Isochronous IN Underflow Error Interrupt" ] # [ inline ] pub fn hbisoinerri ( & self ) -> HBISOINERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HBISOINERRIR { bits } } # [ doc = "Bit 4 - High Bandwidth Isochronous IN Flush Interrupt" ] # [ inline ] pub fn hbisoflushi ( & self ) -> HBISOFLUSHIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HBISOFLUSHIR { bits } } # [ doc = "Bit 5 - Overflow Interrupt" ] # [ inline ] pub fn overfi ( & self ) -> OVERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIR { bits } } # [ doc = "Bit 6 - CRC Error Interrupt" ] # [ inline ] pub fn crcerri ( & self ) -> CRCERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CRCERRIR { bits } } # [ doc = "Bit 7 - Short Packet Interrupt" ] # [ inline ] pub fn shortpacket ( & self ) -> SHORTPACKETR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETR { bits } } # [ doc = "Bits 8:9 - Data Toggle Sequence" ] # [ inline ] pub fn dtseq ( & self ) -> DTSEQR { DTSEQR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - High-bandwidth Isochronous OUT Endpoint Transaction Error Interrupt" ] # [ inline ] pub fn errortrans ( & self ) -> ERRORTRANSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRORTRANSR { bits } } # [ doc = "Bits 12:13 - Number of Busy Banks" ] # [ inline ] pub fn nbusybk ( & self ) -> NBUSYBKR { NBUSYBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Current Bank" ] # [ inline ] pub fn currbk ( & self ) -> CURRBKR { CURRBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Read-write Allowed" ] # [ inline ] pub fn rwall ( & self ) -> RWALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RWALLR { bits } } # [ doc = "Bit 18 - Configuration OK Status" ] # [ inline ] pub fn cfgok ( & self ) -> CFGOKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFGOKR { bits } } # [ doc = "Bits 20:30 - Byte Count" ] # [ inline ] pub fn byct ( & self ) -> BYCTR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BYCTR { bits } } } } # [ doc = "Device Endpoint Clear Register (n = 0)" ] pub struct DEVEPTICR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Clear Register (n = 0)" ] pub mod devepticr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTICR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINICW < 'a > { w : & 'a mut W , } impl < 'a > _TXINICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTICW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTPICW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTPICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKOUTICW < 'a > { w : & 'a mut W , } impl < 'a > _NAKOUTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKINICW < 'a > { w : & 'a mut W , } impl < 'a > _NAKINICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFICW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STALLEDICW < 'a > { w : & 'a mut W , } impl < 'a > _STALLEDICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETCW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transmitted IN Data Interrupt Clear" ] # [ inline ] pub fn txinic ( & mut self ) -> _TXINICW { _TXINICW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Clear" ] # [ inline ] pub fn rxoutic ( & mut self ) -> _RXOUTICW { _RXOUTICW { w : self } } # [ doc = "Bit 2 - Received SETUP Interrupt Clear" ] # [ inline ] pub fn rxstpic ( & mut self ) -> _RXSTPICW { _RXSTPICW { w : self } } # [ doc = "Bit 3 - NAKed OUT Interrupt Clear" ] # [ inline ] pub fn nakoutic ( & mut self ) -> _NAKOUTICW { _NAKOUTICW { w : self } } # [ doc = "Bit 4 - NAKed IN Interrupt Clear" ] # [ inline ] pub fn nakinic ( & mut self ) -> _NAKINICW { _NAKINICW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Clear" ] # [ inline ] pub fn overfic ( & mut self ) -> _OVERFICW { _OVERFICW { w : self } } # [ doc = "Bit 6 - STALLed Interrupt Clear" ] # [ inline ] pub fn stalledic ( & mut self ) -> _STALLEDICW { _STALLEDICW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Clear" ] # [ inline ] pub fn shortpacketc ( & mut self ) -> _SHORTPACKETCW { _SHORTPACKETCW { w : self } } } } # [ doc = "Device Endpoint Clear Register (n = 0)" ] pub struct DEVEPTICR0_ISOENPT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Clear Register (n = 0)" ] pub mod devepticr0_isoenpt { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTICR0_ISOENPT { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINICW < 'a > { w : & 'a mut W , } impl < 'a > _TXINICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTICW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFICW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOINERRICW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOINERRICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOFLUSHICW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOFLUSHICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFICW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRICW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETCW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transmitted IN Data Interrupt Clear" ] # [ inline ] pub fn txinic ( & mut self ) -> _TXINICW { _TXINICW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Clear" ] # [ inline ] pub fn rxoutic ( & mut self ) -> _RXOUTICW { _RXOUTICW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Clear" ] # [ inline ] pub fn underfic ( & mut self ) -> _UNDERFICW { _UNDERFICW { w : self } } # [ doc = "Bit 3 - High bandwidth isochronous IN Underflow Error Interrupt Clear" ] # [ inline ] pub fn hbisoinerric ( & mut self ) -> _HBISOINERRICW { _HBISOINERRICW { w : self } } # [ doc = "Bit 4 - High Bandwidth Isochronous IN Flush Interrupt Clear" ] # [ inline ] pub fn hbisoflushic ( & mut self ) -> _HBISOFLUSHICW { _HBISOFLUSHICW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Clear" ] # [ inline ] pub fn overfic ( & mut self ) -> _OVERFICW { _OVERFICW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Clear" ] # [ inline ] pub fn crcerric ( & mut self ) -> _CRCERRICW { _CRCERRICW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Clear" ] # [ inline ] pub fn shortpacketc ( & mut self ) -> _SHORTPACKETCW { _SHORTPACKETCW { w : self } } } } # [ doc = "Device Endpoint Set Register (n = 0)" ] pub struct DEVEPTIFR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Set Register (n = 0)" ] pub mod deveptifr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTIFR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINISW < 'a > { w : & 'a mut W , } impl < 'a > _TXINISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTISW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTPISW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTPISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKOUTISW < 'a > { w : & 'a mut W , } impl < 'a > _NAKOUTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKINISW < 'a > { w : & 'a mut W , } impl < 'a > _NAKINISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFISW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STALLEDISW < 'a > { w : & 'a mut W , } impl < 'a > _STALLEDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETSW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKSW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Transmitted IN Data Interrupt Set" ] # [ inline ] pub fn txinis ( & mut self ) -> _TXINISW { _TXINISW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Set" ] # [ inline ] pub fn rxoutis ( & mut self ) -> _RXOUTISW { _RXOUTISW { w : self } } # [ doc = "Bit 2 - Received SETUP Interrupt Set" ] # [ inline ] pub fn rxstpis ( & mut self ) -> _RXSTPISW { _RXSTPISW { w : self } } # [ doc = "Bit 3 - NAKed OUT Interrupt Set" ] # [ inline ] pub fn nakoutis ( & mut self ) -> _NAKOUTISW { _NAKOUTISW { w : self } } # [ doc = "Bit 4 - NAKed IN Interrupt Set" ] # [ inline ] pub fn nakinis ( & mut self ) -> _NAKINISW { _NAKINISW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Set" ] # [ inline ] pub fn overfis ( & mut self ) -> _OVERFISW { _OVERFISW { w : self } } # [ doc = "Bit 6 - STALLed Interrupt Set" ] # [ inline ] pub fn stalledis ( & mut self ) -> _STALLEDISW { _STALLEDISW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Set" ] # [ inline ] pub fn shortpackets ( & mut self ) -> _SHORTPACKETSW { _SHORTPACKETSW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Set" ] # [ inline ] pub fn nbusybks ( & mut self ) -> _NBUSYBKSW { _NBUSYBKSW { w : self } } } } # [ doc = "Device Endpoint Set Register (n = 0)" ] pub struct DEVEPTIFR0_ISOENPT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Set Register (n = 0)" ] pub mod deveptifr0_isoenpt { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTIFR0_ISOENPT { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINISW < 'a > { w : & 'a mut W , } impl < 'a > _TXINISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTISW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFISW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOINERRISW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOINERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOFLUSHISW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOFLUSHISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFISW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRISW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETSW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKSW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Transmitted IN Data Interrupt Set" ] # [ inline ] pub fn txinis ( & mut self ) -> _TXINISW { _TXINISW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Set" ] # [ inline ] pub fn rxoutis ( & mut self ) -> _RXOUTISW { _RXOUTISW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Set" ] # [ inline ] pub fn underfis ( & mut self ) -> _UNDERFISW { _UNDERFISW { w : self } } # [ doc = "Bit 3 - High bandwidth isochronous IN Underflow Error Interrupt Set" ] # [ inline ] pub fn hbisoinerris ( & mut self ) -> _HBISOINERRISW { _HBISOINERRISW { w : self } } # [ doc = "Bit 4 - High Bandwidth Isochronous IN Flush Interrupt Set" ] # [ inline ] pub fn hbisoflushis ( & mut self ) -> _HBISOFLUSHISW { _HBISOFLUSHISW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Set" ] # [ inline ] pub fn overfis ( & mut self ) -> _OVERFISW { _OVERFISW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Set" ] # [ inline ] pub fn crcerris ( & mut self ) -> _CRCERRISW { _CRCERRISW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Set" ] # [ inline ] pub fn shortpackets ( & mut self ) -> _SHORTPACKETSW { _SHORTPACKETSW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Set" ] # [ inline ] pub fn nbusybks ( & mut self ) -> _NBUSYBKSW { _NBUSYBKSW { w : self } } } } # [ doc = "Device Endpoint Mask Register (n = 0)" ] pub struct DEVEPTIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Mask Register (n = 0)" ] pub mod deveptimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: DEVEPTIMR { # [ 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 TXINER { bits : bool , } impl TXINER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXOUTER { bits : bool , } impl RXOUTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSTPER { bits : bool , } impl RXSTPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKOUTER { bits : bool , } impl NAKOUTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKINER { bits : bool , } impl NAKINER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFER { bits : bool , } impl OVERFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STALLEDER { bits : bool , } impl STALLEDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETER { bits : bool , } impl SHORTPACKETER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NBUSYBKER { bits : bool , } impl NBUSYBKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct KILLBKR { bits : bool , } impl KILLBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FIFOCONR { bits : bool , } impl FIFOCONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPDISHDMAR { bits : bool , } impl EPDISHDMAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NYETDISR { bits : bool , } impl NYETDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSTDTR { bits : bool , } impl RSTDTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STALLRQR { bits : bool , } impl STALLRQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmitted IN Data Interrupt" ] # [ inline ] pub fn txine ( & self ) -> TXINER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXINER { bits } } # [ doc = "Bit 1 - Received OUT Data Interrupt" ] # [ inline ] pub fn rxoute ( & self ) -> RXOUTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXOUTER { bits } } # [ doc = "Bit 2 - Received SETUP Interrupt" ] # [ inline ] pub fn rxstpe ( & self ) -> RXSTPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSTPER { bits } } # [ doc = "Bit 3 - NAKed OUT Interrupt" ] # [ inline ] pub fn nakoute ( & self ) -> NAKOUTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKOUTER { bits } } # [ doc = "Bit 4 - NAKed IN Interrupt" ] # [ inline ] pub fn nakine ( & self ) -> NAKINER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKINER { bits } } # [ doc = "Bit 5 - Overflow Interrupt" ] # [ inline ] pub fn overfe ( & self ) -> OVERFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFER { bits } } # [ doc = "Bit 6 - STALLed Interrupt" ] # [ inline ] pub fn stallede ( & self ) -> STALLEDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STALLEDER { bits } } # [ doc = "Bit 7 - Short Packet Interrupt" ] # [ inline ] pub fn shortpackete ( & self ) -> SHORTPACKETER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETER { bits } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt" ] # [ inline ] pub fn nbusybke ( & self ) -> NBUSYBKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NBUSYBKER { bits } } # [ doc = "Bit 13 - Kill IN Bank" ] # [ inline ] pub fn killbk ( & self ) -> KILLBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; KILLBKR { bits } } # [ doc = "Bit 14 - FIFO Control" ] # [ inline ] pub fn fifocon ( & self ) -> FIFOCONR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOCONR { bits } } # [ doc = "Bit 16 - Endpoint Interrupts Disable HDMA Request" ] # [ inline ] pub fn epdishdma ( & self ) -> EPDISHDMAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPDISHDMAR { bits } } # [ doc = "Bit 17 - NYET Token Disable" ] # [ inline ] pub fn nyetdis ( & self ) -> NYETDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NYETDISR { bits } } # [ doc = "Bit 18 - Reset Data Toggle" ] # [ inline ] pub fn rstdt ( & self ) -> RSTDTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSTDTR { bits } } # [ doc = "Bit 19 - STALL Request" ] # [ inline ] pub fn stallrq ( & self ) -> STALLRQR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STALLRQR { bits } } } } # [ doc = "Device Endpoint Mask Register (n = 0)" ] pub struct DEVEPTIMR0_ISOENPT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Mask Register (n = 0)" ] pub mod deveptimr0_isoenpt { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: DEVEPTIMR0_ISOENPT { # [ 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 TXINER { bits : bool , } impl TXINER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXOUTER { bits : bool , } impl RXOUTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDERFER { bits : bool , } impl UNDERFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HBISOINERRER { bits : bool , } impl HBISOINERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HBISOFLUSHER { bits : bool , } impl HBISOFLUSHER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFER { bits : bool , } impl OVERFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CRCERRER { bits : bool , } impl CRCERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETER { bits : bool , } impl SHORTPACKETER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MDATAER { bits : bool , } impl MDATAER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DATAXER { bits : bool , } impl DATAXER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRORTRANSER { bits : bool , } impl ERRORTRANSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NBUSYBKER { bits : bool , } impl NBUSYBKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct KILLBKR { bits : bool , } impl KILLBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FIFOCONR { bits : bool , } impl FIFOCONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EPDISHDMAR { bits : bool , } impl EPDISHDMAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSTDTR { bits : bool , } impl RSTDTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmitted IN Data Interrupt" ] # [ inline ] pub fn txine ( & self ) -> TXINER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXINER { bits } } # [ doc = "Bit 1 - Received OUT Data Interrupt" ] # [ inline ] pub fn rxoute ( & self ) -> RXOUTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXOUTER { bits } } # [ doc = "Bit 2 - Underflow Interrupt" ] # [ inline ] pub fn underfe ( & self ) -> UNDERFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDERFER { bits } } # [ doc = "Bit 3 - High Bandwidth Isochronous IN Error Interrupt" ] # [ inline ] pub fn hbisoinerre ( & self ) -> HBISOINERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HBISOINERRER { bits } } # [ doc = "Bit 4 - High Bandwidth Isochronous IN Flush Interrupt" ] # [ inline ] pub fn hbisoflushe ( & self ) -> HBISOFLUSHER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HBISOFLUSHER { bits } } # [ doc = "Bit 5 - Overflow Interrupt" ] # [ inline ] pub fn overfe ( & self ) -> OVERFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFER { bits } } # [ doc = "Bit 6 - CRC Error Interrupt" ] # [ inline ] pub fn crcerre ( & self ) -> CRCERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CRCERRER { bits } } # [ doc = "Bit 7 - Short Packet Interrupt" ] # [ inline ] pub fn shortpackete ( & self ) -> SHORTPACKETER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETER { bits } } # [ doc = "Bit 8 - MData Interrupt" ] # [ inline ] pub fn mdatae ( & self ) -> MDATAER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MDATAER { bits } } # [ doc = "Bit 9 - DataX Interrupt" ] # [ inline ] pub fn dataxe ( & self ) -> DATAXER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DATAXER { bits } } # [ doc = "Bit 10 - Transaction Error Interrupt" ] # [ inline ] pub fn errortranse ( & self ) -> ERRORTRANSER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRORTRANSER { bits } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt" ] # [ inline ] pub fn nbusybke ( & self ) -> NBUSYBKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NBUSYBKER { bits } } # [ doc = "Bit 13 - Kill IN Bank" ] # [ inline ] pub fn killbk ( & self ) -> KILLBKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; KILLBKR { bits } } # [ doc = "Bit 14 - FIFO Control" ] # [ inline ] pub fn fifocon ( & self ) -> FIFOCONR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOCONR { bits } } # [ doc = "Bit 16 - Endpoint Interrupts Disable HDMA Request" ] # [ inline ] pub fn epdishdma ( & self ) -> EPDISHDMAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EPDISHDMAR { bits } } # [ doc = "Bit 18 - Reset Data Toggle" ] # [ inline ] pub fn rstdt ( & self ) -> RSTDTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSTDTR { bits } } } } # [ doc = "Device Endpoint Enable Register (n = 0)" ] pub struct DEVEPTIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Enable Register (n = 0)" ] pub mod deveptier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINESW < 'a > { w : & 'a mut W , } impl < 'a > _TXINESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTESW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTPESW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTPESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKOUTESW < 'a > { w : & 'a mut W , } impl < 'a > _NAKOUTESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKINESW < 'a > { w : & 'a mut W , } impl < 'a > _NAKINESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFESW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STALLEDESW < 'a > { w : & 'a mut W , } impl < 'a > _STALLEDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETESW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKESW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KILLBKSW < 'a > { w : & 'a mut W , } impl < 'a > _KILLBKSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOCONSW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCONSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPDISHDMASW < 'a > { w : & 'a mut W , } impl < 'a > _EPDISHDMASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NYETDISSW < 'a > { w : & 'a mut W , } impl < 'a > _NYETDISSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTDTSW < 'a > { w : & 'a mut W , } impl < 'a > _RSTDTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STALLRQSW < 'a > { w : & 'a mut W , } impl < 'a > _STALLRQSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transmitted IN Data Interrupt Enable" ] # [ inline ] pub fn txines ( & mut self ) -> _TXINESW { _TXINESW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Enable" ] # [ inline ] pub fn rxoutes ( & mut self ) -> _RXOUTESW { _RXOUTESW { w : self } } # [ doc = "Bit 2 - Received SETUP Interrupt Enable" ] # [ inline ] pub fn rxstpes ( & mut self ) -> _RXSTPESW { _RXSTPESW { w : self } } # [ doc = "Bit 3 - NAKed OUT Interrupt Enable" ] # [ inline ] pub fn nakoutes ( & mut self ) -> _NAKOUTESW { _NAKOUTESW { w : self } } # [ doc = "Bit 4 - NAKed IN Interrupt Enable" ] # [ inline ] pub fn nakines ( & mut self ) -> _NAKINESW { _NAKINESW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfes ( & mut self ) -> _OVERFESW { _OVERFESW { w : self } } # [ doc = "Bit 6 - STALLed Interrupt Enable" ] # [ inline ] pub fn stalledes ( & mut self ) -> _STALLEDESW { _STALLEDESW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketes ( & mut self ) -> _SHORTPACKETESW { _SHORTPACKETESW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Enable" ] # [ inline ] pub fn nbusybkes ( & mut self ) -> _NBUSYBKESW { _NBUSYBKESW { w : self } } # [ doc = "Bit 13 - Kill IN Bank" ] # [ inline ] pub fn killbks ( & mut self ) -> _KILLBKSW { _KILLBKSW { w : self } } # [ doc = "Bit 14 - FIFO Control" ] # [ inline ] pub fn fifocons ( & mut self ) -> _FIFOCONSW { _FIFOCONSW { w : self } } # [ doc = "Bit 16 - Endpoint Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn epdishdmas ( & mut self ) -> _EPDISHDMASW { _EPDISHDMASW { w : self } } # [ doc = "Bit 17 - NYET Token Disable Enable" ] # [ inline ] pub fn nyetdiss ( & mut self ) -> _NYETDISSW { _NYETDISSW { w : self } } # [ doc = "Bit 18 - Reset Data Toggle Enable" ] # [ inline ] pub fn rstdts ( & mut self ) -> _RSTDTSW { _RSTDTSW { w : self } } # [ doc = "Bit 19 - STALL Request Enable" ] # [ inline ] pub fn stallrqs ( & mut self ) -> _STALLRQSW { _STALLRQSW { w : self } } } } # [ doc = "Device Endpoint Enable Register (n = 0)" ] pub struct DEVEPTIER0_ISOENPT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Enable Register (n = 0)" ] pub mod deveptier0_isoenpt { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTIER0_ISOENPT { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINESW < 'a > { w : & 'a mut W , } impl < 'a > _TXINESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTESW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFESW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOINERRESW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOINERRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOFLUSHESW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOFLUSHESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFESW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRESW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETESW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MDATAESW < 'a > { w : & 'a mut W , } impl < 'a > _MDATAESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DATAXESW < 'a > { w : & 'a mut W , } impl < 'a > _DATAXESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRORTRANSESW < 'a > { w : & 'a mut W , } impl < 'a > _ERRORTRANSESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKESW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KILLBKSW < 'a > { w : & 'a mut W , } impl < 'a > _KILLBKSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOCONSW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCONSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPDISHDMASW < 'a > { w : & 'a mut W , } impl < 'a > _EPDISHDMASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTDTSW < 'a > { w : & 'a mut W , } impl < 'a > _RSTDTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STALLRQSW < 'a > { w : & 'a mut W , } impl < 'a > _STALLRQSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transmitted IN Data Interrupt Enable" ] # [ inline ] pub fn txines ( & mut self ) -> _TXINESW { _TXINESW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Enable" ] # [ inline ] pub fn rxoutes ( & mut self ) -> _RXOUTESW { _RXOUTESW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Enable" ] # [ inline ] pub fn underfes ( & mut self ) -> _UNDERFESW { _UNDERFESW { w : self } } # [ doc = "Bit 3 - High Bandwidth Isochronous IN Error Interrupt Enable" ] # [ inline ] pub fn hbisoinerres ( & mut self ) -> _HBISOINERRESW { _HBISOINERRESW { w : self } } # [ doc = "Bit 4 - High Bandwidth Isochronous IN Flush Interrupt Enable" ] # [ inline ] pub fn hbisoflushes ( & mut self ) -> _HBISOFLUSHESW { _HBISOFLUSHESW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfes ( & mut self ) -> _OVERFESW { _OVERFESW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Enable" ] # [ inline ] pub fn crcerres ( & mut self ) -> _CRCERRESW { _CRCERRESW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketes ( & mut self ) -> _SHORTPACKETESW { _SHORTPACKETESW { w : self } } # [ doc = "Bit 8 - MData Interrupt Enable" ] # [ inline ] pub fn mdataes ( & mut self ) -> _MDATAESW { _MDATAESW { w : self } } # [ doc = "Bit 9 - DataX Interrupt Enable" ] # [ inline ] pub fn dataxes ( & mut self ) -> _DATAXESW { _DATAXESW { w : self } } # [ doc = "Bit 10 - Transaction Error Interrupt Enable" ] # [ inline ] pub fn errortranses ( & mut self ) -> _ERRORTRANSESW { _ERRORTRANSESW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Enable" ] # [ inline ] pub fn nbusybkes ( & mut self ) -> _NBUSYBKESW { _NBUSYBKESW { w : self } } # [ doc = "Bit 13 - Kill IN Bank" ] # [ inline ] pub fn killbks ( & mut self ) -> _KILLBKSW { _KILLBKSW { w : self } } # [ doc = "Bit 14 - FIFO Control" ] # [ inline ] pub fn fifocons ( & mut self ) -> _FIFOCONSW { _FIFOCONSW { w : self } } # [ doc = "Bit 16 - Endpoint Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn epdishdmas ( & mut self ) -> _EPDISHDMASW { _EPDISHDMASW { w : self } } # [ doc = "Bit 18 - Reset Data Toggle Enable" ] # [ inline ] pub fn rstdts ( & mut self ) -> _RSTDTSW { _RSTDTSW { w : self } } # [ doc = "Bit 19 - STALL Request Enable" ] # [ inline ] pub fn stallrqs ( & mut self ) -> _STALLRQSW { _STALLRQSW { w : self } } } } # [ doc = "Device Endpoint Disable Register (n = 0)" ] pub struct DEVEPTIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Disable Register (n = 0)" ] pub mod deveptidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINECW < 'a > { w : & 'a mut W , } impl < 'a > _TXINECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTECW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTPECW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTPECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKOUTECW < 'a > { w : & 'a mut W , } impl < 'a > _NAKOUTECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKINECW < 'a > { w : & 'a mut W , } impl < 'a > _NAKINECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFECW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STALLEDECW < 'a > { w : & 'a mut W , } impl < 'a > _STALLEDECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETECW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKECW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOCONCW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCONCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPDISHDMACW < 'a > { w : & 'a mut W , } impl < 'a > _EPDISHDMACW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NYETDISCW < 'a > { w : & 'a mut W , } impl < 'a > _NYETDISCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STALLRQCW < 'a > { w : & 'a mut W , } impl < 'a > _STALLRQCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transmitted IN Interrupt Clear" ] # [ inline ] pub fn txinec ( & mut self ) -> _TXINECW { _TXINECW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Clear" ] # [ inline ] pub fn rxoutec ( & mut self ) -> _RXOUTECW { _RXOUTECW { w : self } } # [ doc = "Bit 2 - Received SETUP Interrupt Clear" ] # [ inline ] pub fn rxstpec ( & mut self ) -> _RXSTPECW { _RXSTPECW { w : self } } # [ doc = "Bit 3 - NAKed OUT Interrupt Clear" ] # [ inline ] pub fn nakoutec ( & mut self ) -> _NAKOUTECW { _NAKOUTECW { w : self } } # [ doc = "Bit 4 - NAKed IN Interrupt Clear" ] # [ inline ] pub fn nakinec ( & mut self ) -> _NAKINECW { _NAKINECW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Clear" ] # [ inline ] pub fn overfec ( & mut self ) -> _OVERFECW { _OVERFECW { w : self } } # [ doc = "Bit 6 - STALLed Interrupt Clear" ] # [ inline ] pub fn stalledec ( & mut self ) -> _STALLEDECW { _STALLEDECW { w : self } } # [ doc = "Bit 7 - Shortpacket Interrupt Clear" ] # [ inline ] pub fn shortpacketec ( & mut self ) -> _SHORTPACKETECW { _SHORTPACKETECW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Clear" ] # [ inline ] pub fn nbusybkec ( & mut self ) -> _NBUSYBKECW { _NBUSYBKECW { w : self } } # [ doc = "Bit 14 - FIFO Control Clear" ] # [ inline ] pub fn fifoconc ( & mut self ) -> _FIFOCONCW { _FIFOCONCW { w : self } } # [ doc = "Bit 16 - Endpoint Interrupts Disable HDMA Request Clear" ] # [ inline ] pub fn epdishdmac ( & mut self ) -> _EPDISHDMACW { _EPDISHDMACW { w : self } } # [ doc = "Bit 17 - NYET Token Disable Clear" ] # [ inline ] pub fn nyetdisc ( & mut self ) -> _NYETDISCW { _NYETDISCW { w : self } } # [ doc = "Bit 19 - STALL Request Clear" ] # [ inline ] pub fn stallrqc ( & mut self ) -> _STALLRQCW { _STALLRQCW { w : self } } } } # [ doc = "Device Endpoint Disable Register (n = 0)" ] pub struct DEVEPTIDR0_ISOENPT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device Endpoint Disable Register (n = 0)" ] pub mod deveptidr0_isoenpt { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DEVEPTIDR0_ISOENPT { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXINECW < 'a > { w : & 'a mut W , } impl < 'a > _TXINECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXOUTECW < 'a > { w : & 'a mut W , } impl < 'a > _RXOUTECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFECW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOINERRECW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOINERRECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HBISOFLUSHECW < 'a > { w : & 'a mut W , } impl < 'a > _HBISOFLUSHECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFECW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRECW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETECW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MDATECW < 'a > { w : & 'a mut W , } impl < 'a > _MDATECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DATAXECW < 'a > { w : & 'a mut W , } impl < 'a > _DATAXECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRORTRANSECW < 'a > { w : & 'a mut W , } impl < 'a > _ERRORTRANSECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKECW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOCONCW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCONCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EPDISHDMACW < 'a > { w : & 'a mut W , } impl < 'a > _EPDISHDMACW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transmitted IN Interrupt Clear" ] # [ inline ] pub fn txinec ( & mut self ) -> _TXINECW { _TXINECW { w : self } } # [ doc = "Bit 1 - Received OUT Data Interrupt Clear" ] # [ inline ] pub fn rxoutec ( & mut self ) -> _RXOUTECW { _RXOUTECW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Clear" ] # [ inline ] pub fn underfec ( & mut self ) -> _UNDERFECW { _UNDERFECW { w : self } } # [ doc = "Bit 3 - High Bandwidth Isochronous IN Error Interrupt Clear" ] # [ inline ] pub fn hbisoinerrec ( & mut self ) -> _HBISOINERRECW { _HBISOINERRECW { w : self } } # [ doc = "Bit 4 - High Bandwidth Isochronous IN Flush Interrupt Clear" ] # [ inline ] pub fn hbisoflushec ( & mut self ) -> _HBISOFLUSHECW { _HBISOFLUSHECW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Clear" ] # [ inline ] pub fn overfec ( & mut self ) -> _OVERFECW { _OVERFECW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Clear" ] # [ inline ] pub fn crcerrec ( & mut self ) -> _CRCERRECW { _CRCERRECW { w : self } } # [ doc = "Bit 7 - Shortpacket Interrupt Clear" ] # [ inline ] pub fn shortpacketec ( & mut self ) -> _SHORTPACKETECW { _SHORTPACKETECW { w : self } } # [ doc = "Bit 8 - MData Interrupt Clear" ] # [ inline ] pub fn mdatec ( & mut self ) -> _MDATECW { _MDATECW { w : self } } # [ doc = "Bit 9 - DataX Interrupt Clear" ] # [ inline ] pub fn dataxec ( & mut self ) -> _DATAXECW { _DATAXECW { w : self } } # [ doc = "Bit 10 - Transaction Error Interrupt Clear" ] # [ inline ] pub fn errortransec ( & mut self ) -> _ERRORTRANSECW { _ERRORTRANSECW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Clear" ] # [ inline ] pub fn nbusybkec ( & mut self ) -> _NBUSYBKECW { _NBUSYBKECW { w : self } } # [ doc = "Bit 14 - FIFO Control Clear" ] # [ inline ] pub fn fifoconc ( & mut self ) -> _FIFOCONCW { _FIFOCONCW { w : self } } # [ doc = "Bit 16 - Endpoint Interrupts Disable HDMA Request Clear" ] # [ inline ] pub fn epdishdmac ( & mut self ) -> _EPDISHDMACW { _EPDISHDMACW { w : self } } } } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 1)" ] pub struct DEVDMANXTDSC1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 1)" ] pub mod devdmanxtdsc1 { # [ 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 :: DEVDMANXTDSC1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Device DMA Channel Address Register (n = 1)" ] pub struct DEVDMAADDRESS1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Address Register (n = 1)" ] pub mod devdmaaddress1 { # [ 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 :: DEVDMAADDRESS1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Device DMA Channel Control Register (n = 1)" ] pub struct DEVDMACONTROL1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Control Register (n = 1)" ] pub mod devdmacontrol1 { # [ 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 :: DEVDMACONTROL1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Device DMA Channel Status Register (n = 1)" ] pub struct DEVDMASTATUS1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Status Register (n = 1)" ] pub mod devdmastatus1 { # [ 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 :: DEVDMASTATUS1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 2)" ] pub struct DEVDMANXTDSC2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 2)" ] pub mod devdmanxtdsc2 { # [ 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 :: DEVDMANXTDSC2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Device DMA Channel Address Register (n = 2)" ] pub struct DEVDMAADDRESS2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Address Register (n = 2)" ] pub mod devdmaaddress2 { # [ 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 :: DEVDMAADDRESS2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Device DMA Channel Control Register (n = 2)" ] pub struct DEVDMACONTROL2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Control Register (n = 2)" ] pub mod devdmacontrol2 { # [ 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 :: DEVDMACONTROL2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Device DMA Channel Status Register (n = 2)" ] pub struct DEVDMASTATUS2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Status Register (n = 2)" ] pub mod devdmastatus2 { # [ 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 :: DEVDMASTATUS2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 3)" ] pub struct DEVDMANXTDSC3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 3)" ] pub mod devdmanxtdsc3 { # [ 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 :: DEVDMANXTDSC3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Device DMA Channel Address Register (n = 3)" ] pub struct DEVDMAADDRESS3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Address Register (n = 3)" ] pub mod devdmaaddress3 { # [ 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 :: DEVDMAADDRESS3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Device DMA Channel Control Register (n = 3)" ] pub struct DEVDMACONTROL3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Control Register (n = 3)" ] pub mod devdmacontrol3 { # [ 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 :: DEVDMACONTROL3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Device DMA Channel Status Register (n = 3)" ] pub struct DEVDMASTATUS3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Status Register (n = 3)" ] pub mod devdmastatus3 { # [ 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 :: DEVDMASTATUS3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 4)" ] pub struct DEVDMANXTDSC4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 4)" ] pub mod devdmanxtdsc4 { # [ 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 :: DEVDMANXTDSC4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Device DMA Channel Address Register (n = 4)" ] pub struct DEVDMAADDRESS4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Address Register (n = 4)" ] pub mod devdmaaddress4 { # [ 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 :: DEVDMAADDRESS4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Device DMA Channel Control Register (n = 4)" ] pub struct DEVDMACONTROL4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Control Register (n = 4)" ] pub mod devdmacontrol4 { # [ 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 :: DEVDMACONTROL4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Device DMA Channel Status Register (n = 4)" ] pub struct DEVDMASTATUS4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Status Register (n = 4)" ] pub mod devdmastatus4 { # [ 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 :: DEVDMASTATUS4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 5)" ] pub struct DEVDMANXTDSC5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 5)" ] pub mod devdmanxtdsc5 { # [ 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 :: DEVDMANXTDSC5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Device DMA Channel Address Register (n = 5)" ] pub struct DEVDMAADDRESS5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Address Register (n = 5)" ] pub mod devdmaaddress5 { # [ 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 :: DEVDMAADDRESS5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Device DMA Channel Control Register (n = 5)" ] pub struct DEVDMACONTROL5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Control Register (n = 5)" ] pub mod devdmacontrol5 { # [ 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 :: DEVDMACONTROL5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Device DMA Channel Status Register (n = 5)" ] pub struct DEVDMASTATUS5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Status Register (n = 5)" ] pub mod devdmastatus5 { # [ 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 :: DEVDMASTATUS5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 6)" ] pub struct DEVDMANXTDSC6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 6)" ] pub mod devdmanxtdsc6 { # [ 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 :: DEVDMANXTDSC6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Device DMA Channel Address Register (n = 6)" ] pub struct DEVDMAADDRESS6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Address Register (n = 6)" ] pub mod devdmaaddress6 { # [ 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 :: DEVDMAADDRESS6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Device DMA Channel Control Register (n = 6)" ] pub struct DEVDMACONTROL6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Control Register (n = 6)" ] pub mod devdmacontrol6 { # [ 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 :: DEVDMACONTROL6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Device DMA Channel Status Register (n = 6)" ] pub struct DEVDMASTATUS6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Status Register (n = 6)" ] pub mod devdmastatus6 { # [ 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 :: DEVDMASTATUS6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 7)" ] pub struct DEVDMANXTDSC7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Next Descriptor Address Register (n = 7)" ] pub mod devdmanxtdsc7 { # [ 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 :: DEVDMANXTDSC7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Device DMA Channel Address Register (n = 7)" ] pub struct DEVDMAADDRESS7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Address Register (n = 7)" ] pub mod devdmaaddress7 { # [ 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 :: DEVDMAADDRESS7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Device DMA Channel Control Register (n = 7)" ] pub struct DEVDMACONTROL7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Control Register (n = 7)" ] pub mod devdmacontrol7 { # [ 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 :: DEVDMACONTROL7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable Control" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Device DMA Channel Status Register (n = 7)" ] pub struct DEVDMASTATUS7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Device DMA Channel Status Register (n = 7)" ] pub mod devdmastatus7 { # [ 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 :: DEVDMASTATUS7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Host General Control Register" ] pub struct HSTCTRL { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host General Control Register" ] pub mod hstctrl { # [ 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 :: HSTCTRL { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SOFER { bits : bool , } impl SOFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ 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 RESUMER { bits : bool , } impl RESUMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `SPDCONF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SPDCONFR { # [ doc = "The host starts in full-speed mode and performs a high-speed reset to switch to the high-speed mode if the downstream peripheral is high-speed capable." ] NORMAL , # [ doc = "For a better consumption, if high-speed is not needed." ] LOW_POWER , # [ doc = "Forced high speed." ] HIGH_SPEED , # [ doc = "The host remains to full-speed mode whatever the peripheral speed capability." ] FORCED_FS } impl SPDCONFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SPDCONFR :: NORMAL => 0 , SPDCONFR :: LOW_POWER => 0x01 , SPDCONFR :: HIGH_SPEED => 0x02 , SPDCONFR :: FORCED_FS => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SPDCONFR { match value { 0 => SPDCONFR :: NORMAL , 1 => SPDCONFR :: LOW_POWER , 2 => SPDCONFR :: HIGH_SPEED , 3 => SPDCONFR :: FORCED_FS , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == SPDCONFR :: NORMAL } # [ doc = "Checks if the value of the field is `LOW_POWER`" ] # [ inline ] pub fn is_low_power ( & self ) -> bool { * self == SPDCONFR :: LOW_POWER } # [ doc = "Checks if the value of the field is `HIGH_SPEED`" ] # [ inline ] pub fn is_high_speed ( & self ) -> bool { * self == SPDCONFR :: HIGH_SPEED } # [ doc = "Checks if the value of the field is `FORCED_FS`" ] # [ inline ] pub fn is_forced_fs ( & self ) -> bool { * self == SPDCONFR :: FORCED_FS } } # [ doc = r" Proxy" ] pub struct _SOFEW < 'a > { w : & 'a mut W , } impl < 'a > _SOFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _RESUMEW < 'a > { w : & 'a mut W , } impl < 'a > _RESUMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SPDCONF`" ] pub enum SPDCONFW { # [ doc = "The host starts in full-speed mode and performs a high-speed reset to switch to the high-speed mode if the downstream peripheral is high-speed capable." ] NORMAL , # [ doc = "For a better consumption, if high-speed is not needed." ] LOW_POWER , # [ doc = "Forced high speed." ] HIGH_SPEED , # [ doc = "The host remains to full-speed mode whatever the peripheral speed capability." ] FORCED_FS } impl SPDCONFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SPDCONFW :: NORMAL => 0 , SPDCONFW :: LOW_POWER => 1 , SPDCONFW :: HIGH_SPEED => 2 , SPDCONFW :: FORCED_FS => 3 } } } # [ doc = r" Proxy" ] pub struct _SPDCONFW < 'a > { w : & 'a mut W , } impl < 'a > _SPDCONFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SPDCONFW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "The host starts in full-speed mode and performs a high-speed reset to switch to the high-speed mode if the downstream peripheral is high-speed capable." ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: NORMAL ) } # [ doc = "For a better consumption, if high-speed is not needed." ] # [ inline ] pub fn low_power ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: LOW_POWER ) } # [ doc = "Forced high speed." ] # [ inline ] pub fn high_speed ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: HIGH_SPEED ) } # [ doc = "The host remains to full-speed mode whatever the peripheral speed capability." ] # [ inline ] pub fn forced_fs ( self ) -> & 'a mut W { self . variant ( SPDCONFW :: FORCED_FS ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 8 - Start of Frame Generation Enable" ] # [ inline ] pub fn sofe ( & self ) -> SOFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SOFER { bits } } # [ doc = "Bit 9 - Send USB Reset" ] # [ inline ] pub fn reset ( & self ) -> RESETR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RESETR { bits } } # [ doc = "Bit 10 - Send USB Resume" ] # [ inline ] pub fn resume ( & self ) -> RESUMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RESUMER { bits } } # [ doc = "Bits 12:13 - Mode Configuration" ] # [ inline ] pub fn spdconf ( & self ) -> SPDCONFR { SPDCONFR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Start of Frame Generation Enable" ] # [ inline ] pub fn sofe ( & mut self ) -> _SOFEW { _SOFEW { w : self } } # [ doc = "Bit 9 - Send USB Reset" ] # [ inline ] pub fn reset ( & mut self ) -> _RESETW { _RESETW { w : self } } # [ doc = "Bit 10 - Send USB Resume" ] # [ inline ] pub fn resume ( & mut self ) -> _RESUMEW { _RESUMEW { w : self } } # [ doc = "Bits 12:13 - Mode Configuration" ] # [ inline ] pub fn spdconf ( & mut self ) -> _SPDCONFW { _SPDCONFW { w : self } } } } # [ doc = "Host Global Interrupt Status Register" ] pub struct HSTISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Global Interrupt Status Register" ] pub mod hstisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTISR { # [ 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 DCONNIR { bits : bool , } impl DCONNIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DDISCIR { bits : bool , } impl DDISCIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSTIR { bits : bool , } impl RSTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSMEDIR { bits : bool , } impl RSMEDIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRSMIR { bits : bool , } impl RXRSMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HSOFIR { bits : bool , } impl HSOFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HWUPIR { bits : bool , } impl HWUPIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_0R { bits : bool , } impl PEP_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 PEP_1R { bits : bool , } impl PEP_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_2R { bits : bool , } impl PEP_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_3R { bits : bool , } impl PEP_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_4R { bits : bool , } impl PEP_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_5R { bits : bool , } impl PEP_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_6R { bits : bool , } impl PEP_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_7R { bits : bool , } impl PEP_7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_8R { bits : bool , } impl PEP_8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_9R { bits : bool , } impl PEP_9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_1R { bits : bool , } impl DMA_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_2R { bits : bool , } impl DMA_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_3R { bits : bool , } impl DMA_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_4R { bits : bool , } impl DMA_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_5R { bits : bool , } impl DMA_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_6R { bits : bool , } impl DMA_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Device Connection Interrupt" ] # [ inline ] pub fn dconni ( & self ) -> DCONNIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCONNIR { bits } } # [ doc = "Bit 1 - Device Disconnection Interrupt" ] # [ inline ] pub fn ddisci ( & self ) -> DDISCIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DDISCIR { bits } } # [ doc = "Bit 2 - USB Reset Sent Interrupt" ] # [ inline ] pub fn rsti ( & self ) -> RSTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSTIR { bits } } # [ doc = "Bit 3 - Downstream Resume Sent Interrupt" ] # [ inline ] pub fn rsmedi ( & self ) -> RSMEDIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSMEDIR { bits } } # [ doc = "Bit 4 - Upstream Resume Received Interrupt" ] # [ inline ] pub fn rxrsmi ( & self ) -> RXRSMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRSMIR { bits } } # [ doc = "Bit 5 - Host Start of Frame Interrupt" ] # [ inline ] pub fn hsofi ( & self ) -> HSOFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HSOFIR { bits } } # [ doc = "Bit 6 - Host Wake-Up Interrupt" ] # [ inline ] pub fn hwupi ( & self ) -> HWUPIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HWUPIR { bits } } # [ doc = "Bit 8 - Pipe 0 Interrupt" ] # [ inline ] pub fn pep_0 ( & self ) -> PEP_0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_0R { bits } } # [ doc = "Bit 9 - Pipe 1 Interrupt" ] # [ inline ] pub fn pep_1 ( & self ) -> PEP_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_1R { bits } } # [ doc = "Bit 10 - Pipe 2 Interrupt" ] # [ inline ] pub fn pep_2 ( & self ) -> PEP_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_2R { bits } } # [ doc = "Bit 11 - Pipe 3 Interrupt" ] # [ inline ] pub fn pep_3 ( & self ) -> PEP_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_3R { bits } } # [ doc = "Bit 12 - Pipe 4 Interrupt" ] # [ inline ] pub fn pep_4 ( & self ) -> PEP_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_4R { bits } } # [ doc = "Bit 13 - Pipe 5 Interrupt" ] # [ inline ] pub fn pep_5 ( & self ) -> PEP_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_5R { bits } } # [ doc = "Bit 14 - Pipe 6 Interrupt" ] # [ inline ] pub fn pep_6 ( & self ) -> PEP_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_6R { bits } } # [ doc = "Bit 15 - Pipe 7 Interrupt" ] # [ inline ] pub fn pep_7 ( & self ) -> PEP_7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_7R { bits } } # [ doc = "Bit 16 - Pipe 8 Interrupt" ] # [ inline ] pub fn pep_8 ( & self ) -> PEP_8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_8R { bits } } # [ doc = "Bit 17 - Pipe 9 Interrupt" ] # [ inline ] pub fn pep_9 ( & self ) -> PEP_9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_9R { bits } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt" ] # [ inline ] pub fn dma_1 ( & self ) -> DMA_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_1R { bits } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt" ] # [ inline ] pub fn dma_2 ( & self ) -> DMA_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_2R { bits } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt" ] # [ inline ] pub fn dma_3 ( & self ) -> DMA_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_3R { bits } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt" ] # [ inline ] pub fn dma_4 ( & self ) -> DMA_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_4R { bits } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt" ] # [ inline ] pub fn dma_5 ( & self ) -> DMA_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_5R { bits } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt" ] # [ inline ] pub fn dma_6 ( & self ) -> DMA_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_6R { bits } } } } # [ doc = "Host Global Interrupt Clear Register" ] pub struct HSTICR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Global Interrupt Clear Register" ] pub mod hsticr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTICR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DCONNICW < 'a > { w : & 'a mut W , } impl < 'a > _DCONNICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DDISCICW < 'a > { w : & 'a mut W , } impl < 'a > _DDISCICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTICW < 'a > { w : & 'a mut W , } impl < 'a > _RSTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSMEDICW < 'a > { w : & 'a mut W , } impl < 'a > _RSMEDICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRSMICW < 'a > { w : & 'a mut W , } impl < 'a > _RXRSMICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HSOFICW < 'a > { w : & 'a mut W , } impl < 'a > _HSOFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HWUPICW < 'a > { w : & 'a mut W , } impl < 'a > _HWUPICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Device Connection Interrupt Clear" ] # [ inline ] pub fn dconnic ( & mut self ) -> _DCONNICW { _DCONNICW { w : self } } # [ doc = "Bit 1 - Device Disconnection Interrupt Clear" ] # [ inline ] pub fn ddiscic ( & mut self ) -> _DDISCICW { _DDISCICW { w : self } } # [ doc = "Bit 2 - USB Reset Sent Interrupt Clear" ] # [ inline ] pub fn rstic ( & mut self ) -> _RSTICW { _RSTICW { w : self } } # [ doc = "Bit 3 - Downstream Resume Sent Interrupt Clear" ] # [ inline ] pub fn rsmedic ( & mut self ) -> _RSMEDICW { _RSMEDICW { w : self } } # [ doc = "Bit 4 - Upstream Resume Received Interrupt Clear" ] # [ inline ] pub fn rxrsmic ( & mut self ) -> _RXRSMICW { _RXRSMICW { w : self } } # [ doc = "Bit 5 - Host Start of Frame Interrupt Clear" ] # [ inline ] pub fn hsofic ( & mut self ) -> _HSOFICW { _HSOFICW { w : self } } # [ doc = "Bit 6 - Host Wake-Up Interrupt Clear" ] # [ inline ] pub fn hwupic ( & mut self ) -> _HWUPICW { _HWUPICW { w : self } } } } # [ doc = "Host Global Interrupt Set Register" ] pub struct HSTIFR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Global Interrupt Set Register" ] pub mod hstifr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTIFR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DCONNISW < 'a > { w : & 'a mut W , } impl < 'a > _DCONNISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DDISCISW < 'a > { w : & 'a mut W , } impl < 'a > _DDISCISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTISW < 'a > { w : & 'a mut W , } impl < 'a > _RSTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSMEDISW < 'a > { w : & 'a mut W , } impl < 'a > _RSMEDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRSMISW < 'a > { w : & 'a mut W , } impl < 'a > _RXRSMISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HSOFISW < 'a > { w : & 'a mut W , } impl < 'a > _HSOFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HWUPISW < 'a > { w : & 'a mut W , } impl < 'a > _HWUPISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_1W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_2W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_3W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_4W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_5W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_6W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Device Connection Interrupt Set" ] # [ inline ] pub fn dconnis ( & mut self ) -> _DCONNISW { _DCONNISW { w : self } } # [ doc = "Bit 1 - Device Disconnection Interrupt Set" ] # [ inline ] pub fn ddiscis ( & mut self ) -> _DDISCISW { _DDISCISW { w : self } } # [ doc = "Bit 2 - USB Reset Sent Interrupt Set" ] # [ inline ] pub fn rstis ( & mut self ) -> _RSTISW { _RSTISW { w : self } } # [ doc = "Bit 3 - Downstream Resume Sent Interrupt Set" ] # [ inline ] pub fn rsmedis ( & mut self ) -> _RSMEDISW { _RSMEDISW { w : self } } # [ doc = "Bit 4 - Upstream Resume Received Interrupt Set" ] # [ inline ] pub fn rxrsmis ( & mut self ) -> _RXRSMISW { _RXRSMISW { w : self } } # [ doc = "Bit 5 - Host Start of Frame Interrupt Set" ] # [ inline ] pub fn hsofis ( & mut self ) -> _HSOFISW { _HSOFISW { w : self } } # [ doc = "Bit 6 - Host Wake-Up Interrupt Set" ] # [ inline ] pub fn hwupis ( & mut self ) -> _HWUPISW { _HWUPISW { w : self } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Set" ] # [ inline ] pub fn dma_1 ( & mut self ) -> _DMA_1W { _DMA_1W { w : self } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Set" ] # [ inline ] pub fn dma_2 ( & mut self ) -> _DMA_2W { _DMA_2W { w : self } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Set" ] # [ inline ] pub fn dma_3 ( & mut self ) -> _DMA_3W { _DMA_3W { w : self } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Set" ] # [ inline ] pub fn dma_4 ( & mut self ) -> _DMA_4W { _DMA_4W { w : self } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Set" ] # [ inline ] pub fn dma_5 ( & mut self ) -> _DMA_5W { _DMA_5W { w : self } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Set" ] # [ inline ] pub fn dma_6 ( & mut self ) -> _DMA_6W { _DMA_6W { w : self } } } } # [ doc = "Host Global Interrupt Mask Register" ] pub struct HSTIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Global Interrupt Mask Register" ] pub mod hstimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTIMR { # [ 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 DCONNIER { bits : bool , } impl DCONNIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DDISCIER { bits : bool , } impl DDISCIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSTIER { bits : bool , } impl RSTIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSMEDIER { bits : bool , } impl RSMEDIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXRSMIER { bits : bool , } impl RXRSMIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HSOFIER { bits : bool , } impl HSOFIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HWUPIER { bits : bool , } impl HWUPIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_0R { bits : bool , } impl PEP_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 PEP_1R { bits : bool , } impl PEP_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_2R { bits : bool , } impl PEP_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_3R { bits : bool , } impl PEP_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_4R { bits : bool , } impl PEP_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_5R { bits : bool , } impl PEP_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_6R { bits : bool , } impl PEP_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_7R { bits : bool , } impl PEP_7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_8R { bits : bool , } impl PEP_8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEP_9R { bits : bool , } impl PEP_9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_1R { bits : bool , } impl DMA_1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_2R { bits : bool , } impl DMA_2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_3R { bits : bool , } impl DMA_3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_4R { bits : bool , } impl DMA_4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_5R { bits : bool , } impl DMA_5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DMA_6R { bits : bool , } impl DMA_6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Device Connection Interrupt Enable" ] # [ inline ] pub fn dconnie ( & self ) -> DCONNIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCONNIER { bits } } # [ doc = "Bit 1 - Device Disconnection Interrupt Enable" ] # [ inline ] pub fn ddiscie ( & self ) -> DDISCIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DDISCIER { bits } } # [ doc = "Bit 2 - USB Reset Sent Interrupt Enable" ] # [ inline ] pub fn rstie ( & self ) -> RSTIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSTIER { bits } } # [ doc = "Bit 3 - Downstream Resume Sent Interrupt Enable" ] # [ inline ] pub fn rsmedie ( & self ) -> RSMEDIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSMEDIER { bits } } # [ doc = "Bit 4 - Upstream Resume Received Interrupt Enable" ] # [ inline ] pub fn rxrsmie ( & self ) -> RXRSMIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRSMIER { bits } } # [ doc = "Bit 5 - Host Start of Frame Interrupt Enable" ] # [ inline ] pub fn hsofie ( & self ) -> HSOFIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HSOFIER { bits } } # [ doc = "Bit 6 - Host Wake-Up Interrupt Enable" ] # [ inline ] pub fn hwupie ( & self ) -> HWUPIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HWUPIER { bits } } # [ doc = "Bit 8 - Pipe 0 Interrupt Enable" ] # [ inline ] pub fn pep_0 ( & self ) -> PEP_0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_0R { bits } } # [ doc = "Bit 9 - Pipe 1 Interrupt Enable" ] # [ inline ] pub fn pep_1 ( & self ) -> PEP_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_1R { bits } } # [ doc = "Bit 10 - Pipe 2 Interrupt Enable" ] # [ inline ] pub fn pep_2 ( & self ) -> PEP_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_2R { bits } } # [ doc = "Bit 11 - Pipe 3 Interrupt Enable" ] # [ inline ] pub fn pep_3 ( & self ) -> PEP_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_3R { bits } } # [ doc = "Bit 12 - Pipe 4 Interrupt Enable" ] # [ inline ] pub fn pep_4 ( & self ) -> PEP_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_4R { bits } } # [ doc = "Bit 13 - Pipe 5 Interrupt Enable" ] # [ inline ] pub fn pep_5 ( & self ) -> PEP_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_5R { bits } } # [ doc = "Bit 14 - Pipe 6 Interrupt Enable" ] # [ inline ] pub fn pep_6 ( & self ) -> PEP_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_6R { bits } } # [ doc = "Bit 15 - Pipe 7 Interrupt Enable" ] # [ inline ] pub fn pep_7 ( & self ) -> PEP_7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_7R { bits } } # [ doc = "Bit 16 - Pipe 8 Interrupt Enable" ] # [ inline ] pub fn pep_8 ( & self ) -> PEP_8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_8R { bits } } # [ doc = "Bit 17 - Pipe 9 Interrupt Enable" ] # [ inline ] pub fn pep_9 ( & self ) -> PEP_9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEP_9R { bits } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Enable" ] # [ inline ] pub fn dma_1 ( & self ) -> DMA_1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_1R { bits } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Enable" ] # [ inline ] pub fn dma_2 ( & self ) -> DMA_2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_2R { bits } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Enable" ] # [ inline ] pub fn dma_3 ( & self ) -> DMA_3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_3R { bits } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Enable" ] # [ inline ] pub fn dma_4 ( & self ) -> DMA_4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_4R { bits } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Enable" ] # [ inline ] pub fn dma_5 ( & self ) -> DMA_5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_5R { bits } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Enable" ] # [ inline ] pub fn dma_6 ( & self ) -> DMA_6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DMA_6R { bits } } } } # [ doc = "Host Global Interrupt Disable Register" ] pub struct HSTIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Global Interrupt Disable Register" ] pub mod hstidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DCONNIECW < 'a > { w : & 'a mut W , } impl < 'a > _DCONNIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DDISCIECW < 'a > { w : & 'a mut W , } impl < 'a > _DDISCIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTIECW < 'a > { w : & 'a mut W , } impl < 'a > _RSTIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSMEDIECW < 'a > { w : & 'a mut W , } impl < 'a > _RSMEDIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRSMIECW < 'a > { w : & 'a mut W , } impl < 'a > _RXRSMIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HSOFIECW < 'a > { w : & 'a mut W , } impl < 'a > _HSOFIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HWUPIECW < 'a > { w : & 'a mut W , } impl < 'a > _HWUPIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_0W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _PEP_1W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_2W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_3W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_4W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_5W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_6W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_7W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_8W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_9W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_1W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_2W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_3W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_4W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_5W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_6W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Device Connection Interrupt Disable" ] # [ inline ] pub fn dconniec ( & mut self ) -> _DCONNIECW { _DCONNIECW { w : self } } # [ doc = "Bit 1 - Device Disconnection Interrupt Disable" ] # [ inline ] pub fn ddisciec ( & mut self ) -> _DDISCIECW { _DDISCIECW { w : self } } # [ doc = "Bit 2 - USB Reset Sent Interrupt Disable" ] # [ inline ] pub fn rstiec ( & mut self ) -> _RSTIECW { _RSTIECW { w : self } } # [ doc = "Bit 3 - Downstream Resume Sent Interrupt Disable" ] # [ inline ] pub fn rsmediec ( & mut self ) -> _RSMEDIECW { _RSMEDIECW { w : self } } # [ doc = "Bit 4 - Upstream Resume Received Interrupt Disable" ] # [ inline ] pub fn rxrsmiec ( & mut self ) -> _RXRSMIECW { _RXRSMIECW { w : self } } # [ doc = "Bit 5 - Host Start of Frame Interrupt Disable" ] # [ inline ] pub fn hsofiec ( & mut self ) -> _HSOFIECW { _HSOFIECW { w : self } } # [ doc = "Bit 6 - Host Wake-Up Interrupt Disable" ] # [ inline ] pub fn hwupiec ( & mut self ) -> _HWUPIECW { _HWUPIECW { w : self } } # [ doc = "Bit 8 - Pipe 0 Interrupt Disable" ] # [ inline ] pub fn pep_0 ( & mut self ) -> _PEP_0W { _PEP_0W { w : self } } # [ doc = "Bit 9 - Pipe 1 Interrupt Disable" ] # [ inline ] pub fn pep_1 ( & mut self ) -> _PEP_1W { _PEP_1W { w : self } } # [ doc = "Bit 10 - Pipe 2 Interrupt Disable" ] # [ inline ] pub fn pep_2 ( & mut self ) -> _PEP_2W { _PEP_2W { w : self } } # [ doc = "Bit 11 - Pipe 3 Interrupt Disable" ] # [ inline ] pub fn pep_3 ( & mut self ) -> _PEP_3W { _PEP_3W { w : self } } # [ doc = "Bit 12 - Pipe 4 Interrupt Disable" ] # [ inline ] pub fn pep_4 ( & mut self ) -> _PEP_4W { _PEP_4W { w : self } } # [ doc = "Bit 13 - Pipe 5 Interrupt Disable" ] # [ inline ] pub fn pep_5 ( & mut self ) -> _PEP_5W { _PEP_5W { w : self } } # [ doc = "Bit 14 - Pipe 6 Interrupt Disable" ] # [ inline ] pub fn pep_6 ( & mut self ) -> _PEP_6W { _PEP_6W { w : self } } # [ doc = "Bit 15 - Pipe 7 Interrupt Disable" ] # [ inline ] pub fn pep_7 ( & mut self ) -> _PEP_7W { _PEP_7W { w : self } } # [ doc = "Bit 16 - Pipe 8 Interrupt Disable" ] # [ inline ] pub fn pep_8 ( & mut self ) -> _PEP_8W { _PEP_8W { w : self } } # [ doc = "Bit 17 - Pipe 9 Interrupt Disable" ] # [ inline ] pub fn pep_9 ( & mut self ) -> _PEP_9W { _PEP_9W { w : self } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Disable" ] # [ inline ] pub fn dma_1 ( & mut self ) -> _DMA_1W { _DMA_1W { w : self } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Disable" ] # [ inline ] pub fn dma_2 ( & mut self ) -> _DMA_2W { _DMA_2W { w : self } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Disable" ] # [ inline ] pub fn dma_3 ( & mut self ) -> _DMA_3W { _DMA_3W { w : self } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Disable" ] # [ inline ] pub fn dma_4 ( & mut self ) -> _DMA_4W { _DMA_4W { w : self } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Disable" ] # [ inline ] pub fn dma_5 ( & mut self ) -> _DMA_5W { _DMA_5W { w : self } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Disable" ] # [ inline ] pub fn dma_6 ( & mut self ) -> _DMA_6W { _DMA_6W { w : self } } } } # [ doc = "Host Global Interrupt Enable Register" ] pub struct HSTIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Global Interrupt Enable Register" ] pub mod hstier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DCONNIESW < 'a > { w : & 'a mut W , } impl < 'a > _DCONNIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DDISCIESW < 'a > { w : & 'a mut W , } impl < 'a > _DDISCIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTIESW < 'a > { w : & 'a mut W , } impl < 'a > _RSTIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSMEDIESW < 'a > { w : & 'a mut W , } impl < 'a > _RSMEDIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXRSMIESW < 'a > { w : & 'a mut W , } impl < 'a > _RXRSMIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HSOFIESW < 'a > { w : & 'a mut W , } impl < 'a > _HSOFIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HWUPIESW < 'a > { w : & 'a mut W , } impl < 'a > _HWUPIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_0W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _PEP_1W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_2W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_3W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_4W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_5W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_6W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_7W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_8W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEP_9W < 'a > { w : & 'a mut W , } impl < 'a > _PEP_9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_1W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_2W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_3W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_4W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_5W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DMA_6W < 'a > { w : & 'a mut W , } impl < 'a > _DMA_6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Device Connection Interrupt Enable" ] # [ inline ] pub fn dconnies ( & mut self ) -> _DCONNIESW { _DCONNIESW { w : self } } # [ doc = "Bit 1 - Device Disconnection Interrupt Enable" ] # [ inline ] pub fn ddiscies ( & mut self ) -> _DDISCIESW { _DDISCIESW { w : self } } # [ doc = "Bit 2 - USB Reset Sent Interrupt Enable" ] # [ inline ] pub fn rsties ( & mut self ) -> _RSTIESW { _RSTIESW { w : self } } # [ doc = "Bit 3 - Downstream Resume Sent Interrupt Enable" ] # [ inline ] pub fn rsmedies ( & mut self ) -> _RSMEDIESW { _RSMEDIESW { w : self } } # [ doc = "Bit 4 - Upstream Resume Received Interrupt Enable" ] # [ inline ] pub fn rxrsmies ( & mut self ) -> _RXRSMIESW { _RXRSMIESW { w : self } } # [ doc = "Bit 5 - Host Start of Frame Interrupt Enable" ] # [ inline ] pub fn hsofies ( & mut self ) -> _HSOFIESW { _HSOFIESW { w : self } } # [ doc = "Bit 6 - Host Wake-Up Interrupt Enable" ] # [ inline ] pub fn hwupies ( & mut self ) -> _HWUPIESW { _HWUPIESW { w : self } } # [ doc = "Bit 8 - Pipe 0 Interrupt Enable" ] # [ inline ] pub fn pep_0 ( & mut self ) -> _PEP_0W { _PEP_0W { w : self } } # [ doc = "Bit 9 - Pipe 1 Interrupt Enable" ] # [ inline ] pub fn pep_1 ( & mut self ) -> _PEP_1W { _PEP_1W { w : self } } # [ doc = "Bit 10 - Pipe 2 Interrupt Enable" ] # [ inline ] pub fn pep_2 ( & mut self ) -> _PEP_2W { _PEP_2W { w : self } } # [ doc = "Bit 11 - Pipe 3 Interrupt Enable" ] # [ inline ] pub fn pep_3 ( & mut self ) -> _PEP_3W { _PEP_3W { w : self } } # [ doc = "Bit 12 - Pipe 4 Interrupt Enable" ] # [ inline ] pub fn pep_4 ( & mut self ) -> _PEP_4W { _PEP_4W { w : self } } # [ doc = "Bit 13 - Pipe 5 Interrupt Enable" ] # [ inline ] pub fn pep_5 ( & mut self ) -> _PEP_5W { _PEP_5W { w : self } } # [ doc = "Bit 14 - Pipe 6 Interrupt Enable" ] # [ inline ] pub fn pep_6 ( & mut self ) -> _PEP_6W { _PEP_6W { w : self } } # [ doc = "Bit 15 - Pipe 7 Interrupt Enable" ] # [ inline ] pub fn pep_7 ( & mut self ) -> _PEP_7W { _PEP_7W { w : self } } # [ doc = "Bit 16 - Pipe 8 Interrupt Enable" ] # [ inline ] pub fn pep_8 ( & mut self ) -> _PEP_8W { _PEP_8W { w : self } } # [ doc = "Bit 17 - Pipe 9 Interrupt Enable" ] # [ inline ] pub fn pep_9 ( & mut self ) -> _PEP_9W { _PEP_9W { w : self } } # [ doc = "Bit 25 - DMA Channel 1 Interrupt Enable" ] # [ inline ] pub fn dma_1 ( & mut self ) -> _DMA_1W { _DMA_1W { w : self } } # [ doc = "Bit 26 - DMA Channel 2 Interrupt Enable" ] # [ inline ] pub fn dma_2 ( & mut self ) -> _DMA_2W { _DMA_2W { w : self } } # [ doc = "Bit 27 - DMA Channel 3 Interrupt Enable" ] # [ inline ] pub fn dma_3 ( & mut self ) -> _DMA_3W { _DMA_3W { w : self } } # [ doc = "Bit 28 - DMA Channel 4 Interrupt Enable" ] # [ inline ] pub fn dma_4 ( & mut self ) -> _DMA_4W { _DMA_4W { w : self } } # [ doc = "Bit 29 - DMA Channel 5 Interrupt Enable" ] # [ inline ] pub fn dma_5 ( & mut self ) -> _DMA_5W { _DMA_5W { w : self } } # [ doc = "Bit 30 - DMA Channel 6 Interrupt Enable" ] # [ inline ] pub fn dma_6 ( & mut self ) -> _DMA_6W { _DMA_6W { w : self } } } } # [ doc = "Host Pipe Register" ] pub struct HSTPIP { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Register" ] pub mod hstpip { # [ 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 :: HSTPIP { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 PEN0R { bits : bool , } impl PEN0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN1R { bits : bool , } impl PEN1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN2R { bits : bool , } impl PEN2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN3R { bits : bool , } impl PEN3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN4R { bits : bool , } impl PEN4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN5R { bits : bool , } impl PEN5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN6R { bits : bool , } impl PEN6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN7R { bits : bool , } impl PEN7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PEN8R { bits : bool , } impl PEN8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST0R { bits : bool , } impl PRST0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST1R { bits : bool , } impl PRST1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST2R { bits : bool , } impl PRST2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST3R { bits : bool , } impl PRST3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST4R { bits : bool , } impl PRST4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST5R { bits : bool , } impl PRST5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST6R { bits : bool , } impl PRST6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST7R { bits : bool , } impl PRST7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PRST8R { bits : bool , } impl PRST8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _PEN0W < 'a > { w : & 'a mut W , } impl < 'a > _PEN0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN1W < 'a > { w : & 'a mut W , } impl < 'a > _PEN1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN2W < 'a > { w : & 'a mut W , } impl < 'a > _PEN2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN3W < 'a > { w : & 'a mut W , } impl < 'a > _PEN3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN4W < 'a > { w : & 'a mut W , } impl < 'a > _PEN4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN5W < 'a > { w : & 'a mut W , } impl < 'a > _PEN5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN6W < 'a > { w : & 'a mut W , } impl < 'a > _PEN6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN7W < 'a > { w : & 'a mut W , } impl < 'a > _PEN7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PEN8W < 'a > { w : & 'a mut W , } impl < 'a > _PEN8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST0W < 'a > { w : & 'a mut W , } impl < 'a > _PRST0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST1W < 'a > { w : & 'a mut W , } impl < 'a > _PRST1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST2W < 'a > { w : & 'a mut W , } impl < 'a > _PRST2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST3W < 'a > { w : & 'a mut W , } impl < 'a > _PRST3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST4W < 'a > { w : & 'a mut W , } impl < 'a > _PRST4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST5W < 'a > { w : & 'a mut W , } impl < 'a > _PRST5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST6W < 'a > { w : & 'a mut W , } impl < 'a > _PRST6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST7W < 'a > { w : & 'a mut W , } impl < 'a > _PRST7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRST8W < 'a > { w : & 'a mut W , } impl < 'a > _PRST8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Pipe 0 Enable" ] # [ inline ] pub fn pen0 ( & self ) -> PEN0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN0R { bits } } # [ doc = "Bit 1 - Pipe 1 Enable" ] # [ inline ] pub fn pen1 ( & self ) -> PEN1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN1R { bits } } # [ doc = "Bit 2 - Pipe 2 Enable" ] # [ inline ] pub fn pen2 ( & self ) -> PEN2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN2R { bits } } # [ doc = "Bit 3 - Pipe 3 Enable" ] # [ inline ] pub fn pen3 ( & self ) -> PEN3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN3R { bits } } # [ doc = "Bit 4 - Pipe 4 Enable" ] # [ inline ] pub fn pen4 ( & self ) -> PEN4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN4R { bits } } # [ doc = "Bit 5 - Pipe 5 Enable" ] # [ inline ] pub fn pen5 ( & self ) -> PEN5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN5R { bits } } # [ doc = "Bit 6 - Pipe 6 Enable" ] # [ inline ] pub fn pen6 ( & self ) -> PEN6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN6R { bits } } # [ doc = "Bit 7 - Pipe 7 Enable" ] # [ inline ] pub fn pen7 ( & self ) -> PEN7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN7R { bits } } # [ doc = "Bit 8 - Pipe 8 Enable" ] # [ inline ] pub fn pen8 ( & self ) -> PEN8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PEN8R { bits } } # [ doc = "Bit 16 - Pipe 0 Reset" ] # [ inline ] pub fn prst0 ( & self ) -> PRST0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST0R { bits } } # [ doc = "Bit 17 - Pipe 1 Reset" ] # [ inline ] pub fn prst1 ( & self ) -> PRST1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST1R { bits } } # [ doc = "Bit 18 - Pipe 2 Reset" ] # [ inline ] pub fn prst2 ( & self ) -> PRST2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST2R { bits } } # [ doc = "Bit 19 - Pipe 3 Reset" ] # [ inline ] pub fn prst3 ( & self ) -> PRST3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST3R { bits } } # [ doc = "Bit 20 - Pipe 4 Reset" ] # [ inline ] pub fn prst4 ( & self ) -> PRST4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST4R { bits } } # [ doc = "Bit 21 - Pipe 5 Reset" ] # [ inline ] pub fn prst5 ( & self ) -> PRST5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST5R { bits } } # [ doc = "Bit 22 - Pipe 6 Reset" ] # [ inline ] pub fn prst6 ( & self ) -> PRST6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST6R { bits } } # [ doc = "Bit 23 - Pipe 7 Reset" ] # [ inline ] pub fn prst7 ( & self ) -> PRST7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST7R { bits } } # [ doc = "Bit 24 - Pipe 8 Reset" ] # [ inline ] pub fn prst8 ( & self ) -> PRST8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PRST8R { 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 - Pipe 0 Enable" ] # [ inline ] pub fn pen0 ( & mut self ) -> _PEN0W { _PEN0W { w : self } } # [ doc = "Bit 1 - Pipe 1 Enable" ] # [ inline ] pub fn pen1 ( & mut self ) -> _PEN1W { _PEN1W { w : self } } # [ doc = "Bit 2 - Pipe 2 Enable" ] # [ inline ] pub fn pen2 ( & mut self ) -> _PEN2W { _PEN2W { w : self } } # [ doc = "Bit 3 - Pipe 3 Enable" ] # [ inline ] pub fn pen3 ( & mut self ) -> _PEN3W { _PEN3W { w : self } } # [ doc = "Bit 4 - Pipe 4 Enable" ] # [ inline ] pub fn pen4 ( & mut self ) -> _PEN4W { _PEN4W { w : self } } # [ doc = "Bit 5 - Pipe 5 Enable" ] # [ inline ] pub fn pen5 ( & mut self ) -> _PEN5W { _PEN5W { w : self } } # [ doc = "Bit 6 - Pipe 6 Enable" ] # [ inline ] pub fn pen6 ( & mut self ) -> _PEN6W { _PEN6W { w : self } } # [ doc = "Bit 7 - Pipe 7 Enable" ] # [ inline ] pub fn pen7 ( & mut self ) -> _PEN7W { _PEN7W { w : self } } # [ doc = "Bit 8 - Pipe 8 Enable" ] # [ inline ] pub fn pen8 ( & mut self ) -> _PEN8W { _PEN8W { w : self } } # [ doc = "Bit 16 - Pipe 0 Reset" ] # [ inline ] pub fn prst0 ( & mut self ) -> _PRST0W { _PRST0W { w : self } } # [ doc = "Bit 17 - Pipe 1 Reset" ] # [ inline ] pub fn prst1 ( & mut self ) -> _PRST1W { _PRST1W { w : self } } # [ doc = "Bit 18 - Pipe 2 Reset" ] # [ inline ] pub fn prst2 ( & mut self ) -> _PRST2W { _PRST2W { w : self } } # [ doc = "Bit 19 - Pipe 3 Reset" ] # [ inline ] pub fn prst3 ( & mut self ) -> _PRST3W { _PRST3W { w : self } } # [ doc = "Bit 20 - Pipe 4 Reset" ] # [ inline ] pub fn prst4 ( & mut self ) -> _PRST4W { _PRST4W { w : self } } # [ doc = "Bit 21 - Pipe 5 Reset" ] # [ inline ] pub fn prst5 ( & mut self ) -> _PRST5W { _PRST5W { w : self } } # [ doc = "Bit 22 - Pipe 6 Reset" ] # [ inline ] pub fn prst6 ( & mut self ) -> _PRST6W { _PRST6W { w : self } } # [ doc = "Bit 23 - Pipe 7 Reset" ] # [ inline ] pub fn prst7 ( & mut self ) -> _PRST7W { _PRST7W { w : self } } # [ doc = "Bit 24 - Pipe 8 Reset" ] # [ inline ] pub fn prst8 ( & mut self ) -> _PRST8W { _PRST8W { w : self } } } } # [ doc = "Host Frame Number Register" ] pub struct HSTFNUM { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Frame Number Register" ] pub mod hstfnum { # [ 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 :: HSTFNUM { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MFNUMR { bits : u8 , } impl MFNUMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FNUMR { bits : u16 , } impl FNUMR { # [ 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 FLENHIGHR { bits : u8 , } impl FLENHIGHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _MFNUMW < 'a > { w : & 'a mut W , } impl < 'a > _MFNUMW < '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 _FNUMW < 'a > { w : & 'a mut W , } impl < 'a > _FNUMW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _FLENHIGHW < 'a > { w : & 'a mut W , } impl < 'a > _FLENHIGHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:2 - Micro Frame Number" ] # [ inline ] pub fn mfnum ( & self ) -> MFNUMR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MFNUMR { bits } } # [ doc = "Bits 3:13 - Frame Number" ] # [ inline ] pub fn fnum ( & self ) -> FNUMR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; FNUMR { bits } } # [ doc = "Bits 16:23 - Frame Length" ] # [ inline ] pub fn flenhigh ( & self ) -> FLENHIGHR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FLENHIGHR { 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 - Micro Frame Number" ] # [ inline ] pub fn mfnum ( & mut self ) -> _MFNUMW { _MFNUMW { w : self } } # [ doc = "Bits 3:13 - Frame Number" ] # [ inline ] pub fn fnum ( & mut self ) -> _FNUMW { _FNUMW { w : self } } # [ doc = "Bits 16:23 - Frame Length" ] # [ inline ] pub fn flenhigh ( & mut self ) -> _FLENHIGHW { _FLENHIGHW { w : self } } } } # [ doc = "Host Address 1 Register" ] pub struct HSTADDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Address 1 Register" ] pub mod hstaddr1 { # [ 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 :: HSTADDR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 HSTADDRP0R { bits : u8 , } impl HSTADDRP0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HSTADDRP1R { bits : u8 , } impl HSTADDRP1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HSTADDRP2R { bits : u8 , } impl HSTADDRP2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HSTADDRP3R { bits : u8 , } impl HSTADDRP3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _HSTADDRP0W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP0W < '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 } } # [ doc = r" Proxy" ] pub struct _HSTADDRP1W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP1W < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _HSTADDRP2W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP2W < '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 _HSTADDRP3W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP3W < '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 = 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 = "Bits 0:6 - USB Host Address" ] # [ inline ] pub fn hstaddrp0 ( & self ) -> HSTADDRP0R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP0R { bits } } # [ doc = "Bits 8:14 - USB Host Address" ] # [ inline ] pub fn hstaddrp1 ( & self ) -> HSTADDRP1R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP1R { bits } } # [ doc = "Bits 16:22 - USB Host Address" ] # [ inline ] pub fn hstaddrp2 ( & self ) -> HSTADDRP2R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP2R { bits } } # [ doc = "Bits 24:30 - USB Host Address" ] # [ inline ] pub fn hstaddrp3 ( & self ) -> HSTADDRP3R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP3R { 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:6 - USB Host Address" ] # [ inline ] pub fn hstaddrp0 ( & mut self ) -> _HSTADDRP0W { _HSTADDRP0W { w : self } } # [ doc = "Bits 8:14 - USB Host Address" ] # [ inline ] pub fn hstaddrp1 ( & mut self ) -> _HSTADDRP1W { _HSTADDRP1W { w : self } } # [ doc = "Bits 16:22 - USB Host Address" ] # [ inline ] pub fn hstaddrp2 ( & mut self ) -> _HSTADDRP2W { _HSTADDRP2W { w : self } } # [ doc = "Bits 24:30 - USB Host Address" ] # [ inline ] pub fn hstaddrp3 ( & mut self ) -> _HSTADDRP3W { _HSTADDRP3W { w : self } } } } # [ doc = "Host Address 2 Register" ] pub struct HSTADDR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Address 2 Register" ] pub mod hstaddr2 { # [ 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 :: HSTADDR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 HSTADDRP4R { bits : u8 , } impl HSTADDRP4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HSTADDRP5R { bits : u8 , } impl HSTADDRP5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HSTADDRP6R { bits : u8 , } impl HSTADDRP6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HSTADDRP7R { bits : u8 , } impl HSTADDRP7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _HSTADDRP4W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP4W < '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 } } # [ doc = r" Proxy" ] pub struct _HSTADDRP5W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP5W < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _HSTADDRP6W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP6W < '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 _HSTADDRP7W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP7W < '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 = 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 = "Bits 0:6 - USB Host Address" ] # [ inline ] pub fn hstaddrp4 ( & self ) -> HSTADDRP4R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP4R { bits } } # [ doc = "Bits 8:14 - USB Host Address" ] # [ inline ] pub fn hstaddrp5 ( & self ) -> HSTADDRP5R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP5R { bits } } # [ doc = "Bits 16:22 - USB Host Address" ] # [ inline ] pub fn hstaddrp6 ( & self ) -> HSTADDRP6R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP6R { bits } } # [ doc = "Bits 24:30 - USB Host Address" ] # [ inline ] pub fn hstaddrp7 ( & self ) -> HSTADDRP7R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP7R { 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:6 - USB Host Address" ] # [ inline ] pub fn hstaddrp4 ( & mut self ) -> _HSTADDRP4W { _HSTADDRP4W { w : self } } # [ doc = "Bits 8:14 - USB Host Address" ] # [ inline ] pub fn hstaddrp5 ( & mut self ) -> _HSTADDRP5W { _HSTADDRP5W { w : self } } # [ doc = "Bits 16:22 - USB Host Address" ] # [ inline ] pub fn hstaddrp6 ( & mut self ) -> _HSTADDRP6W { _HSTADDRP6W { w : self } } # [ doc = "Bits 24:30 - USB Host Address" ] # [ inline ] pub fn hstaddrp7 ( & mut self ) -> _HSTADDRP7W { _HSTADDRP7W { w : self } } } } # [ doc = "Host Address 3 Register" ] pub struct HSTADDR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Address 3 Register" ] pub mod hstaddr3 { # [ 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 :: HSTADDR3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 HSTADDRP8R { bits : u8 , } impl HSTADDRP8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HSTADDRP9R { bits : u8 , } impl HSTADDRP9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _HSTADDRP8W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP8W < '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 } } # [ doc = r" Proxy" ] pub struct _HSTADDRP9W < 'a > { w : & 'a mut W , } impl < 'a > _HSTADDRP9W < '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 = 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 = "Bits 0:6 - USB Host Address" ] # [ inline ] pub fn hstaddrp8 ( & self ) -> HSTADDRP8R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP8R { bits } } # [ doc = "Bits 8:14 - USB Host Address" ] # [ inline ] pub fn hstaddrp9 ( & self ) -> HSTADDRP9R { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HSTADDRP9R { 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:6 - USB Host Address" ] # [ inline ] pub fn hstaddrp8 ( & mut self ) -> _HSTADDRP8W { _HSTADDRP8W { w : self } } # [ doc = "Bits 8:14 - USB Host Address" ] # [ inline ] pub fn hstaddrp9 ( & mut self ) -> _HSTADDRP9W { _HSTADDRP9W { w : self } } } } # [ doc = "Host Pipe Configuration Register (n = 0)" ] pub struct HSTPIPCFG { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Configuration Register (n = 0)" ] pub mod hstpipcfg { # [ 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 :: HSTPIPCFG { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 ALLOCR { bits : bool , } impl ALLOCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PBKR { # [ doc = "Single-bank pipe" ] _1_BANK , # [ doc = "Double-bank pipe" ] _2_BANK , # [ doc = "Triple-bank pipe" ] _3_BANK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PBKR :: _1_BANK => 0 , PBKR :: _2_BANK => 0x01 , PBKR :: _3_BANK => 0x02 , PBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PBKR { match value { 0 => PBKR :: _1_BANK , 1 => PBKR :: _2_BANK , 2 => PBKR :: _3_BANK , i => PBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1_BANK`" ] # [ inline ] pub fn is_1_bank ( & self ) -> bool { * self == PBKR :: _1_BANK } # [ doc = "Checks if the value of the field is `_2_BANK`" ] # [ inline ] pub fn is_2_bank ( & self ) -> bool { * self == PBKR :: _2_BANK } # [ doc = "Checks if the value of the field is `_3_BANK`" ] # [ inline ] pub fn is_3_bank ( & self ) -> bool { * self == PBKR :: _3_BANK } } # [ doc = "Possible values of the field `PSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PSIZER { # [ doc = "8 bytes" ] _8_BYTE , # [ doc = "16 bytes" ] _16_BYTE , # [ doc = "32 bytes" ] _32_BYTE , # [ doc = "64 bytes" ] _64_BYTE , # [ doc = "128 bytes" ] _128_BYTE , # [ doc = "256 bytes" ] _256_BYTE , # [ doc = "512 bytes" ] _512_BYTE , # [ doc = "1024 bytes" ] _1024_BYTE } impl PSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PSIZER :: _8_BYTE => 0 , PSIZER :: _16_BYTE => 0x01 , PSIZER :: _32_BYTE => 0x02 , PSIZER :: _64_BYTE => 0x03 , PSIZER :: _128_BYTE => 0x04 , PSIZER :: _256_BYTE => 0x05 , PSIZER :: _512_BYTE => 0x06 , PSIZER :: _1024_BYTE => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PSIZER { match value { 0 => PSIZER :: _8_BYTE , 1 => PSIZER :: _16_BYTE , 2 => PSIZER :: _32_BYTE , 3 => PSIZER :: _64_BYTE , 4 => PSIZER :: _128_BYTE , 5 => PSIZER :: _256_BYTE , 6 => PSIZER :: _512_BYTE , 7 => PSIZER :: _1024_BYTE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_8_BYTE`" ] # [ inline ] pub fn is_8_byte ( & self ) -> bool { * self == PSIZER :: _8_BYTE } # [ doc = "Checks if the value of the field is `_16_BYTE`" ] # [ inline ] pub fn is_16_byte ( & self ) -> bool { * self == PSIZER :: _16_BYTE } # [ doc = "Checks if the value of the field is `_32_BYTE`" ] # [ inline ] pub fn is_32_byte ( & self ) -> bool { * self == PSIZER :: _32_BYTE } # [ doc = "Checks if the value of the field is `_64_BYTE`" ] # [ inline ] pub fn is_64_byte ( & self ) -> bool { * self == PSIZER :: _64_BYTE } # [ doc = "Checks if the value of the field is `_128_BYTE`" ] # [ inline ] pub fn is_128_byte ( & self ) -> bool { * self == PSIZER :: _128_BYTE } # [ doc = "Checks if the value of the field is `_256_BYTE`" ] # [ inline ] pub fn is_256_byte ( & self ) -> bool { * self == PSIZER :: _256_BYTE } # [ doc = "Checks if the value of the field is `_512_BYTE`" ] # [ inline ] pub fn is_512_byte ( & self ) -> bool { * self == PSIZER :: _512_BYTE } # [ doc = "Checks if the value of the field is `_1024_BYTE`" ] # [ inline ] pub fn is_1024_byte ( & self ) -> bool { * self == PSIZER :: _1024_BYTE } } # [ doc = "Possible values of the field `PTOKEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PTOKENR { # [ doc = "SETUP" ] SETUP , # [ doc = "IN" ] IN , # [ doc = "OUT" ] OUT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PTOKENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PTOKENR :: SETUP => 0 , PTOKENR :: IN => 0x01 , PTOKENR :: OUT => 0x02 , PTOKENR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PTOKENR { match value { 0 => PTOKENR :: SETUP , 1 => PTOKENR :: IN , 2 => PTOKENR :: OUT , i => PTOKENR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SETUP`" ] # [ inline ] pub fn is_setup ( & self ) -> bool { * self == PTOKENR :: SETUP } # [ doc = "Checks if the value of the field is `IN`" ] # [ inline ] pub fn is_in_ ( & self ) -> bool { * self == PTOKENR :: IN } # [ doc = "Checks if the value of the field is `OUT`" ] # [ inline ] pub fn is_out ( & self ) -> bool { * self == PTOKENR :: OUT } } # [ doc = r" Value of the field" ] pub struct AUTOSWR { bits : bool , } impl AUTOSWR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PTYPE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PTYPER { # [ doc = "Control" ] CTRL , # [ doc = "Isochronous" ] ISO , # [ doc = "Bulk" ] BLK , # [ doc = "Interrupt" ] INTRPT } impl PTYPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PTYPER :: CTRL => 0 , PTYPER :: ISO => 0x01 , PTYPER :: BLK => 0x02 , PTYPER :: INTRPT => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PTYPER { match value { 0 => PTYPER :: CTRL , 1 => PTYPER :: ISO , 2 => PTYPER :: BLK , 3 => PTYPER :: INTRPT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `CTRL`" ] # [ inline ] pub fn is_ctrl ( & self ) -> bool { * self == PTYPER :: CTRL } # [ doc = "Checks if the value of the field is `ISO`" ] # [ inline ] pub fn is_iso ( & self ) -> bool { * self == PTYPER :: ISO } # [ doc = "Checks if the value of the field is `BLK`" ] # [ inline ] pub fn is_blk ( & self ) -> bool { * self == PTYPER :: BLK } # [ doc = "Checks if the value of the field is `INTRPT`" ] # [ inline ] pub fn is_intrpt ( & self ) -> bool { * self == PTYPER :: INTRPT } } # [ doc = r" Value of the field" ] pub struct PEPNUMR { bits : u8 , } impl PEPNUMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct INTFRQR { bits : u8 , } impl INTFRQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _ALLOCW < 'a > { w : & 'a mut W , } impl < 'a > _ALLOCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PBK`" ] pub enum PBKW { # [ doc = "Single-bank pipe" ] _1_BANK , # [ doc = "Double-bank pipe" ] _2_BANK , # [ doc = "Triple-bank pipe" ] _3_BANK } impl PBKW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PBKW :: _1_BANK => 0 , PBKW :: _2_BANK => 1 , PBKW :: _3_BANK => 2 } } } # [ doc = r" Proxy" ] pub struct _PBKW < 'a > { w : & 'a mut W , } impl < 'a > _PBKW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PBKW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Single-bank pipe" ] # [ inline ] pub fn _1_bank ( self ) -> & 'a mut W { self . variant ( PBKW :: _1_BANK ) } # [ doc = "Double-bank pipe" ] # [ inline ] pub fn _2_bank ( self ) -> & 'a mut W { self . variant ( PBKW :: _2_BANK ) } # [ doc = "Triple-bank pipe" ] # [ inline ] pub fn _3_bank ( self ) -> & 'a mut W { self . variant ( PBKW :: _3_BANK ) } # [ 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 = "Values that can be written to the field `PSIZE`" ] pub enum PSIZEW { # [ doc = "8 bytes" ] _8_BYTE , # [ doc = "16 bytes" ] _16_BYTE , # [ doc = "32 bytes" ] _32_BYTE , # [ doc = "64 bytes" ] _64_BYTE , # [ doc = "128 bytes" ] _128_BYTE , # [ doc = "256 bytes" ] _256_BYTE , # [ doc = "512 bytes" ] _512_BYTE , # [ doc = "1024 bytes" ] _1024_BYTE } impl PSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PSIZEW :: _8_BYTE => 0 , PSIZEW :: _16_BYTE => 1 , PSIZEW :: _32_BYTE => 2 , PSIZEW :: _64_BYTE => 3 , PSIZEW :: _128_BYTE => 4 , PSIZEW :: _256_BYTE => 5 , PSIZEW :: _512_BYTE => 6 , PSIZEW :: _1024_BYTE => 7 } } } # [ doc = r" Proxy" ] pub struct _PSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _PSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PSIZEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "8 bytes" ] # [ inline ] pub fn _8_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _8_BYTE ) } # [ doc = "16 bytes" ] # [ inline ] pub fn _16_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _16_BYTE ) } # [ doc = "32 bytes" ] # [ inline ] pub fn _32_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _32_BYTE ) } # [ doc = "64 bytes" ] # [ inline ] pub fn _64_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _64_BYTE ) } # [ doc = "128 bytes" ] # [ inline ] pub fn _128_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _128_BYTE ) } # [ doc = "256 bytes" ] # [ inline ] pub fn _256_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _256_BYTE ) } # [ doc = "512 bytes" ] # [ inline ] pub fn _512_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _512_BYTE ) } # [ doc = "1024 bytes" ] # [ inline ] pub fn _1024_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _1024_BYTE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `PTOKEN`" ] pub enum PTOKENW { # [ doc = "SETUP" ] SETUP , # [ doc = "IN" ] IN , # [ doc = "OUT" ] OUT } impl PTOKENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PTOKENW :: SETUP => 0 , PTOKENW :: IN => 1 , PTOKENW :: OUT => 2 } } } # [ doc = r" Proxy" ] pub struct _PTOKENW < 'a > { w : & 'a mut W , } impl < 'a > _PTOKENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PTOKENW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "SETUP" ] # [ inline ] pub fn setup ( self ) -> & 'a mut W { self . variant ( PTOKENW :: SETUP ) } # [ doc = "IN" ] # [ inline ] pub fn in_ ( self ) -> & 'a mut W { self . variant ( PTOKENW :: IN ) } # [ doc = "OUT" ] # [ inline ] pub fn out ( self ) -> & 'a mut W { self . variant ( PTOKENW :: OUT ) } # [ 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 _AUTOSWW < 'a > { w : & 'a mut W , } impl < 'a > _AUTOSWW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PTYPE`" ] pub enum PTYPEW { # [ doc = "Control" ] CTRL , # [ doc = "Isochronous" ] ISO , # [ doc = "Bulk" ] BLK , # [ doc = "Interrupt" ] INTRPT } impl PTYPEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PTYPEW :: CTRL => 0 , PTYPEW :: ISO => 1 , PTYPEW :: BLK => 2 , PTYPEW :: INTRPT => 3 } } } # [ doc = r" Proxy" ] pub struct _PTYPEW < 'a > { w : & 'a mut W , } impl < 'a > _PTYPEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PTYPEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Control" ] # [ inline ] pub fn ctrl ( self ) -> & 'a mut W { self . variant ( PTYPEW :: CTRL ) } # [ doc = "Isochronous" ] # [ inline ] pub fn iso ( self ) -> & 'a mut W { self . variant ( PTYPEW :: ISO ) } # [ doc = "Bulk" ] # [ inline ] pub fn blk ( self ) -> & 'a mut W { self . variant ( PTYPEW :: BLK ) } # [ doc = "Interrupt" ] # [ inline ] pub fn intrpt ( self ) -> & 'a mut W { self . variant ( PTYPEW :: INTRPT ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _PEPNUMW < 'a > { w : & 'a mut W , } impl < 'a > _PEPNUMW < '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 _INTFRQW < 'a > { w : & 'a mut W , } impl < 'a > _INTFRQW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 1 - Pipe Memory Allocate" ] # [ inline ] pub fn alloc ( & self ) -> ALLOCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ALLOCR { bits } } # [ doc = "Bits 2:3 - Pipe Banks" ] # [ inline ] pub fn pbk ( & self ) -> PBKR { PBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:6 - Pipe Size" ] # [ inline ] pub fn psize ( & self ) -> PSIZER { PSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 8:9 - Pipe Token" ] # [ inline ] pub fn ptoken ( & self ) -> PTOKENR { PTOKENR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - Automatic Switch" ] # [ inline ] pub fn autosw ( & self ) -> AUTOSWR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AUTOSWR { bits } } # [ doc = "Bits 12:13 - Pipe Type" ] # [ inline ] pub fn ptype ( & self ) -> PTYPER { PTYPER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 16:19 - Pipe Endpoint Number" ] # [ inline ] pub fn pepnum ( & self ) -> PEPNUMR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PEPNUMR { bits } } # [ doc = "Bits 24:31 - Pipe Interrupt Request Frequency" ] # [ inline ] pub fn intfrq ( & self ) -> INTFRQR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; INTFRQR { bits } } } impl W { # [ doc = "Bit 1 - Pipe Memory Allocate" ] # [ inline ] pub fn alloc ( & mut self ) -> _ALLOCW { _ALLOCW { w : self } } # [ doc = "Bits 2:3 - Pipe Banks" ] # [ inline ] pub fn pbk ( & mut self ) -> _PBKW { _PBKW { w : self } } # [ doc = "Bits 4:6 - Pipe Size" ] # [ inline ] pub fn psize ( & mut self ) -> _PSIZEW { _PSIZEW { w : self } } # [ doc = "Bits 8:9 - Pipe Token" ] # [ inline ] pub fn ptoken ( & mut self ) -> _PTOKENW { _PTOKENW { w : self } } # [ doc = "Bit 10 - Automatic Switch" ] # [ inline ] pub fn autosw ( & mut self ) -> _AUTOSWW { _AUTOSWW { w : self } } # [ doc = "Bits 12:13 - Pipe Type" ] # [ inline ] pub fn ptype ( & mut self ) -> _PTYPEW { _PTYPEW { w : self } } # [ doc = "Bits 16:19 - Pipe Endpoint Number" ] # [ inline ] pub fn pepnum ( & mut self ) -> _PEPNUMW { _PEPNUMW { w : self } } # [ doc = "Bits 24:31 - Pipe Interrupt Request Frequency" ] # [ inline ] pub fn intfrq ( & mut self ) -> _INTFRQW { _INTFRQW { w : self } } } } # [ doc = "Host Pipe Configuration Register (n = 0)" ] pub struct HSTPIPCFG0_HSBOHSCP { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Configuration Register (n = 0)" ] pub mod hstpipcfg0_hsbohscp { # [ 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 :: HSTPIPCFG0_HSBOHSCP { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 ALLOCR { bits : bool , } impl ALLOCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PBKR { # [ doc = "Single-bank pipe" ] _1_BANK , # [ doc = "Double-bank pipe" ] _2_BANK , # [ doc = "Triple-bank pipe" ] _3_BANK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PBKR :: _1_BANK => 0 , PBKR :: _2_BANK => 0x01 , PBKR :: _3_BANK => 0x02 , PBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PBKR { match value { 0 => PBKR :: _1_BANK , 1 => PBKR :: _2_BANK , 2 => PBKR :: _3_BANK , i => PBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_1_BANK`" ] # [ inline ] pub fn is_1_bank ( & self ) -> bool { * self == PBKR :: _1_BANK } # [ doc = "Checks if the value of the field is `_2_BANK`" ] # [ inline ] pub fn is_2_bank ( & self ) -> bool { * self == PBKR :: _2_BANK } # [ doc = "Checks if the value of the field is `_3_BANK`" ] # [ inline ] pub fn is_3_bank ( & self ) -> bool { * self == PBKR :: _3_BANK } } # [ doc = "Possible values of the field `PSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PSIZER { # [ doc = "8 bytes" ] _8_BYTE , # [ doc = "16 bytes" ] _16_BYTE , # [ doc = "32 bytes" ] _32_BYTE , # [ doc = "64 bytes" ] _64_BYTE , # [ doc = "128 bytes" ] _128_BYTE , # [ doc = "256 bytes" ] _256_BYTE , # [ doc = "512 bytes" ] _512_BYTE , # [ doc = "1024 bytes" ] _1024_BYTE } impl PSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PSIZER :: _8_BYTE => 0 , PSIZER :: _16_BYTE => 0x01 , PSIZER :: _32_BYTE => 0x02 , PSIZER :: _64_BYTE => 0x03 , PSIZER :: _128_BYTE => 0x04 , PSIZER :: _256_BYTE => 0x05 , PSIZER :: _512_BYTE => 0x06 , PSIZER :: _1024_BYTE => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PSIZER { match value { 0 => PSIZER :: _8_BYTE , 1 => PSIZER :: _16_BYTE , 2 => PSIZER :: _32_BYTE , 3 => PSIZER :: _64_BYTE , 4 => PSIZER :: _128_BYTE , 5 => PSIZER :: _256_BYTE , 6 => PSIZER :: _512_BYTE , 7 => PSIZER :: _1024_BYTE , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_8_BYTE`" ] # [ inline ] pub fn is_8_byte ( & self ) -> bool { * self == PSIZER :: _8_BYTE } # [ doc = "Checks if the value of the field is `_16_BYTE`" ] # [ inline ] pub fn is_16_byte ( & self ) -> bool { * self == PSIZER :: _16_BYTE } # [ doc = "Checks if the value of the field is `_32_BYTE`" ] # [ inline ] pub fn is_32_byte ( & self ) -> bool { * self == PSIZER :: _32_BYTE } # [ doc = "Checks if the value of the field is `_64_BYTE`" ] # [ inline ] pub fn is_64_byte ( & self ) -> bool { * self == PSIZER :: _64_BYTE } # [ doc = "Checks if the value of the field is `_128_BYTE`" ] # [ inline ] pub fn is_128_byte ( & self ) -> bool { * self == PSIZER :: _128_BYTE } # [ doc = "Checks if the value of the field is `_256_BYTE`" ] # [ inline ] pub fn is_256_byte ( & self ) -> bool { * self == PSIZER :: _256_BYTE } # [ doc = "Checks if the value of the field is `_512_BYTE`" ] # [ inline ] pub fn is_512_byte ( & self ) -> bool { * self == PSIZER :: _512_BYTE } # [ doc = "Checks if the value of the field is `_1024_BYTE`" ] # [ inline ] pub fn is_1024_byte ( & self ) -> bool { * self == PSIZER :: _1024_BYTE } } # [ doc = "Possible values of the field `PTOKEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PTOKENR { # [ doc = "SETUP" ] SETUP , # [ doc = "IN" ] IN , # [ doc = "OUT" ] OUT , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PTOKENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PTOKENR :: SETUP => 0 , PTOKENR :: IN => 0x01 , PTOKENR :: OUT => 0x02 , PTOKENR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PTOKENR { match value { 0 => PTOKENR :: SETUP , 1 => PTOKENR :: IN , 2 => PTOKENR :: OUT , i => PTOKENR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SETUP`" ] # [ inline ] pub fn is_setup ( & self ) -> bool { * self == PTOKENR :: SETUP } # [ doc = "Checks if the value of the field is `IN`" ] # [ inline ] pub fn is_in_ ( & self ) -> bool { * self == PTOKENR :: IN } # [ doc = "Checks if the value of the field is `OUT`" ] # [ inline ] pub fn is_out ( & self ) -> bool { * self == PTOKENR :: OUT } } # [ doc = r" Value of the field" ] pub struct AUTOSWR { bits : bool , } impl AUTOSWR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `PTYPE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PTYPER { # [ doc = "Control" ] CTRL , # [ doc = "Bulk" ] BLK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PTYPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PTYPER :: CTRL => 0 , PTYPER :: BLK => 0x02 , PTYPER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PTYPER { match value { 0 => PTYPER :: CTRL , 2 => PTYPER :: BLK , i => PTYPER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CTRL`" ] # [ inline ] pub fn is_ctrl ( & self ) -> bool { * self == PTYPER :: CTRL } # [ doc = "Checks if the value of the field is `BLK`" ] # [ inline ] pub fn is_blk ( & self ) -> bool { * self == PTYPER :: BLK } } # [ doc = r" Value of the field" ] pub struct PEPNUMR { bits : u8 , } impl PEPNUMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PINGENR { bits : bool , } impl PINGENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BINTERVALR { bits : u8 , } impl BINTERVALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _ALLOCW < 'a > { w : & 'a mut W , } impl < 'a > _ALLOCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PBK`" ] pub enum PBKW { # [ doc = "Single-bank pipe" ] _1_BANK , # [ doc = "Double-bank pipe" ] _2_BANK , # [ doc = "Triple-bank pipe" ] _3_BANK } impl PBKW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PBKW :: _1_BANK => 0 , PBKW :: _2_BANK => 1 , PBKW :: _3_BANK => 2 } } } # [ doc = r" Proxy" ] pub struct _PBKW < 'a > { w : & 'a mut W , } impl < 'a > _PBKW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PBKW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Single-bank pipe" ] # [ inline ] pub fn _1_bank ( self ) -> & 'a mut W { self . variant ( PBKW :: _1_BANK ) } # [ doc = "Double-bank pipe" ] # [ inline ] pub fn _2_bank ( self ) -> & 'a mut W { self . variant ( PBKW :: _2_BANK ) } # [ doc = "Triple-bank pipe" ] # [ inline ] pub fn _3_bank ( self ) -> & 'a mut W { self . variant ( PBKW :: _3_BANK ) } # [ 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 = "Values that can be written to the field `PSIZE`" ] pub enum PSIZEW { # [ doc = "8 bytes" ] _8_BYTE , # [ doc = "16 bytes" ] _16_BYTE , # [ doc = "32 bytes" ] _32_BYTE , # [ doc = "64 bytes" ] _64_BYTE , # [ doc = "128 bytes" ] _128_BYTE , # [ doc = "256 bytes" ] _256_BYTE , # [ doc = "512 bytes" ] _512_BYTE , # [ doc = "1024 bytes" ] _1024_BYTE } impl PSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PSIZEW :: _8_BYTE => 0 , PSIZEW :: _16_BYTE => 1 , PSIZEW :: _32_BYTE => 2 , PSIZEW :: _64_BYTE => 3 , PSIZEW :: _128_BYTE => 4 , PSIZEW :: _256_BYTE => 5 , PSIZEW :: _512_BYTE => 6 , PSIZEW :: _1024_BYTE => 7 } } } # [ doc = r" Proxy" ] pub struct _PSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _PSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PSIZEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "8 bytes" ] # [ inline ] pub fn _8_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _8_BYTE ) } # [ doc = "16 bytes" ] # [ inline ] pub fn _16_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _16_BYTE ) } # [ doc = "32 bytes" ] # [ inline ] pub fn _32_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _32_BYTE ) } # [ doc = "64 bytes" ] # [ inline ] pub fn _64_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _64_BYTE ) } # [ doc = "128 bytes" ] # [ inline ] pub fn _128_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _128_BYTE ) } # [ doc = "256 bytes" ] # [ inline ] pub fn _256_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _256_BYTE ) } # [ doc = "512 bytes" ] # [ inline ] pub fn _512_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _512_BYTE ) } # [ doc = "1024 bytes" ] # [ inline ] pub fn _1024_byte ( self ) -> & 'a mut W { self . variant ( PSIZEW :: _1024_BYTE ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `PTOKEN`" ] pub enum PTOKENW { # [ doc = "SETUP" ] SETUP , # [ doc = "IN" ] IN , # [ doc = "OUT" ] OUT } impl PTOKENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PTOKENW :: SETUP => 0 , PTOKENW :: IN => 1 , PTOKENW :: OUT => 2 } } } # [ doc = r" Proxy" ] pub struct _PTOKENW < 'a > { w : & 'a mut W , } impl < 'a > _PTOKENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PTOKENW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "SETUP" ] # [ inline ] pub fn setup ( self ) -> & 'a mut W { self . variant ( PTOKENW :: SETUP ) } # [ doc = "IN" ] # [ inline ] pub fn in_ ( self ) -> & 'a mut W { self . variant ( PTOKENW :: IN ) } # [ doc = "OUT" ] # [ inline ] pub fn out ( self ) -> & 'a mut W { self . variant ( PTOKENW :: OUT ) } # [ 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 _AUTOSWW < 'a > { w : & 'a mut W , } impl < 'a > _AUTOSWW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `PTYPE`" ] pub enum PTYPEW { # [ doc = "Control" ] CTRL , # [ doc = "Bulk" ] BLK } impl PTYPEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PTYPEW :: CTRL => 0 , PTYPEW :: BLK => 2 } } } # [ doc = r" Proxy" ] pub struct _PTYPEW < 'a > { w : & 'a mut W , } impl < 'a > _PTYPEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PTYPEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Control" ] # [ inline ] pub fn ctrl ( self ) -> & 'a mut W { self . variant ( PTYPEW :: CTRL ) } # [ doc = "Bulk" ] # [ inline ] pub fn blk ( self ) -> & 'a mut W { self . variant ( PTYPEW :: BLK ) } # [ 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 _PEPNUMW < 'a > { w : & 'a mut W , } impl < 'a > _PEPNUMW < '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 _PINGENW < 'a > { w : & 'a mut W , } impl < 'a > _PINGENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BINTERVALW < 'a > { w : & 'a mut W , } impl < 'a > _BINTERVALW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 1 - Pipe Memory Allocate" ] # [ inline ] pub fn alloc ( & self ) -> ALLOCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ALLOCR { bits } } # [ doc = "Bits 2:3 - Pipe Banks" ] # [ inline ] pub fn pbk ( & self ) -> PBKR { PBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:6 - Pipe Size" ] # [ inline ] pub fn psize ( & self ) -> PSIZER { PSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 8:9 - Pipe Token" ] # [ inline ] pub fn ptoken ( & self ) -> PTOKENR { PTOKENR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 10 - Automatic Switch" ] # [ inline ] pub fn autosw ( & self ) -> AUTOSWR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AUTOSWR { bits } } # [ doc = "Bits 12:13 - Pipe Type" ] # [ inline ] pub fn ptype ( & self ) -> PTYPER { PTYPER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 16:19 - Pipe Endpoint Number" ] # [ inline ] pub fn pepnum ( & self ) -> PEPNUMR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PEPNUMR { bits } } # [ doc = "Bit 20 - Ping Enable" ] # [ inline ] pub fn pingen ( & self ) -> PINGENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PINGENR { bits } } # [ doc = "Bits 24:31 - Binterval Parameter for the Bulk-Out/Ping Transaction" ] # [ inline ] pub fn binterval ( & self ) -> BINTERVALR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BINTERVALR { bits } } } impl W { # [ doc = "Bit 1 - Pipe Memory Allocate" ] # [ inline ] pub fn alloc ( & mut self ) -> _ALLOCW { _ALLOCW { w : self } } # [ doc = "Bits 2:3 - Pipe Banks" ] # [ inline ] pub fn pbk ( & mut self ) -> _PBKW { _PBKW { w : self } } # [ doc = "Bits 4:6 - Pipe Size" ] # [ inline ] pub fn psize ( & mut self ) -> _PSIZEW { _PSIZEW { w : self } } # [ doc = "Bits 8:9 - Pipe Token" ] # [ inline ] pub fn ptoken ( & mut self ) -> _PTOKENW { _PTOKENW { w : self } } # [ doc = "Bit 10 - Automatic Switch" ] # [ inline ] pub fn autosw ( & mut self ) -> _AUTOSWW { _AUTOSWW { w : self } } # [ doc = "Bits 12:13 - Pipe Type" ] # [ inline ] pub fn ptype ( & mut self ) -> _PTYPEW { _PTYPEW { w : self } } # [ doc = "Bits 16:19 - Pipe Endpoint Number" ] # [ inline ] pub fn pepnum ( & mut self ) -> _PEPNUMW { _PEPNUMW { w : self } } # [ doc = "Bit 20 - Ping Enable" ] # [ inline ] pub fn pingen ( & mut self ) -> _PINGENW { _PINGENW { w : self } } # [ doc = "Bits 24:31 - Binterval Parameter for the Bulk-Out/Ping Transaction" ] # [ inline ] pub fn binterval ( & mut self ) -> _BINTERVALW { _BINTERVALW { w : self } } } } # [ doc = "Host Pipe Status Register (n = 0)" ] pub struct HSTPIPISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Status Register (n = 0)" ] pub mod hstpipisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTPIPISR { # [ 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 RXINIR { bits : bool , } impl RXINIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXOUTIR { bits : bool , } impl TXOUTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXSTPIR { bits : bool , } impl TXSTPIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PERRIR { bits : bool , } impl PERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKEDIR { bits : bool , } impl NAKEDIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIR { bits : bool , } impl OVERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSTALLDIR { bits : bool , } impl RXSTALLDIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETIR { bits : bool , } impl SHORTPACKETIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DTSEQ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DTSEQR { # [ doc = "Data0 toggle sequence" ] DATA0 , # [ doc = "Data1 toggle sequence" ] DATA1 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DTSEQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DTSEQR :: DATA0 => 0 , DTSEQR :: DATA1 => 0x01 , DTSEQR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DTSEQR { match value { 0 => DTSEQR :: DATA0 , 1 => DTSEQR :: DATA1 , i => DTSEQR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DATA0`" ] # [ inline ] pub fn is_data0 ( & self ) -> bool { * self == DTSEQR :: DATA0 } # [ doc = "Checks if the value of the field is `DATA1`" ] # [ inline ] pub fn is_data1 ( & self ) -> bool { * self == DTSEQR :: DATA1 } } # [ doc = "Possible values of the field `NBUSYBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBUSYBKR { # [ doc = "0 busy bank (all banks free)" ] _0_BUSY , # [ doc = "1 busy bank" ] _1_BUSY , # [ doc = "2 busy banks" ] _2_BUSY , # [ doc = "3 busy banks" ] _3_BUSY } impl NBUSYBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBUSYBKR :: _0_BUSY => 0 , NBUSYBKR :: _1_BUSY => 0x01 , NBUSYBKR :: _2_BUSY => 0x02 , NBUSYBKR :: _3_BUSY => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBUSYBKR { match value { 0 => NBUSYBKR :: _0_BUSY , 1 => NBUSYBKR :: _1_BUSY , 2 => NBUSYBKR :: _2_BUSY , 3 => NBUSYBKR :: _3_BUSY , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_0_BUSY`" ] # [ inline ] pub fn is_0_busy ( & self ) -> bool { * self == NBUSYBKR :: _0_BUSY } # [ doc = "Checks if the value of the field is `_1_BUSY`" ] # [ inline ] pub fn is_1_busy ( & self ) -> bool { * self == NBUSYBKR :: _1_BUSY } # [ doc = "Checks if the value of the field is `_2_BUSY`" ] # [ inline ] pub fn is_2_busy ( & self ) -> bool { * self == NBUSYBKR :: _2_BUSY } # [ doc = "Checks if the value of the field is `_3_BUSY`" ] # [ inline ] pub fn is_3_busy ( & self ) -> bool { * self == NBUSYBKR :: _3_BUSY } } # [ doc = "Possible values of the field `CURRBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CURRBKR { # [ doc = "Current bank is bank0" ] BANK0 , # [ doc = "Current bank is bank1" ] BANK1 , # [ doc = "Current bank is bank2" ] BANK2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CURRBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CURRBKR :: BANK0 => 0 , CURRBKR :: BANK1 => 0x01 , CURRBKR :: BANK2 => 0x02 , CURRBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CURRBKR { match value { 0 => CURRBKR :: BANK0 , 1 => CURRBKR :: BANK1 , 2 => CURRBKR :: BANK2 , i => CURRBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BANK0`" ] # [ inline ] pub fn is_bank0 ( & self ) -> bool { * self == CURRBKR :: BANK0 } # [ doc = "Checks if the value of the field is `BANK1`" ] # [ inline ] pub fn is_bank1 ( & self ) -> bool { * self == CURRBKR :: BANK1 } # [ doc = "Checks if the value of the field is `BANK2`" ] # [ inline ] pub fn is_bank2 ( & self ) -> bool { * self == CURRBKR :: BANK2 } } # [ doc = r" Value of the field" ] pub struct RWALLR { bits : bool , } impl RWALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFGOKR { bits : bool , } impl CFGOKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PBYCTR { bits : u16 , } impl PBYCTR { # [ 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 = "Bit 0 - Received IN Data Interrupt" ] # [ inline ] pub fn rxini ( & self ) -> RXINIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXINIR { bits } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt" ] # [ inline ] pub fn txouti ( & self ) -> TXOUTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXOUTIR { bits } } # [ doc = "Bit 2 - Transmitted SETUP Interrupt" ] # [ inline ] pub fn txstpi ( & self ) -> TXSTPIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXSTPIR { bits } } # [ doc = "Bit 3 - Pipe Error Interrupt" ] # [ inline ] pub fn perri ( & self ) -> PERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PERRIR { bits } } # [ doc = "Bit 4 - NAKed Interrupt" ] # [ inline ] pub fn nakedi ( & self ) -> NAKEDIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKEDIR { bits } } # [ doc = "Bit 5 - Overflow Interrupt" ] # [ inline ] pub fn overfi ( & self ) -> OVERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIR { bits } } # [ doc = "Bit 6 - Received STALLed Interrupt" ] # [ inline ] pub fn rxstalldi ( & self ) -> RXSTALLDIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSTALLDIR { bits } } # [ doc = "Bit 7 - Short Packet Interrupt" ] # [ inline ] pub fn shortpacketi ( & self ) -> SHORTPACKETIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETIR { bits } } # [ doc = "Bits 8:9 - Data Toggle Sequence" ] # [ inline ] pub fn dtseq ( & self ) -> DTSEQR { DTSEQR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Busy Banks" ] # [ inline ] pub fn nbusybk ( & self ) -> NBUSYBKR { NBUSYBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Current Bank" ] # [ inline ] pub fn currbk ( & self ) -> CURRBKR { CURRBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Read-write Allowed" ] # [ inline ] pub fn rwall ( & self ) -> RWALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RWALLR { bits } } # [ doc = "Bit 18 - Configuration OK Status" ] # [ inline ] pub fn cfgok ( & self ) -> CFGOKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFGOKR { bits } } # [ doc = "Bits 20:30 - Pipe Byte Count" ] # [ inline ] pub fn pbyct ( & self ) -> PBYCTR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; PBYCTR { bits } } } } # [ doc = "Host Pipe Status Register (n = 0)" ] pub struct HSTPIPISR0_INTPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Status Register (n = 0)" ] pub mod hstpipisr0_intpipes { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTPIPISR0_INTPIPES { # [ 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 RXINIR { bits : bool , } impl RXINIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXOUTIR { bits : bool , } impl TXOUTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDERFIR { bits : bool , } impl UNDERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PERRIR { bits : bool , } impl PERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKEDIR { bits : bool , } impl NAKEDIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIR { bits : bool , } impl OVERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSTALLDIR { bits : bool , } impl RXSTALLDIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETIR { bits : bool , } impl SHORTPACKETIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DTSEQ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DTSEQR { # [ doc = "Data0 toggle sequence" ] DATA0 , # [ doc = "Data1 toggle sequence" ] DATA1 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DTSEQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DTSEQR :: DATA0 => 0 , DTSEQR :: DATA1 => 0x01 , DTSEQR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DTSEQR { match value { 0 => DTSEQR :: DATA0 , 1 => DTSEQR :: DATA1 , i => DTSEQR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DATA0`" ] # [ inline ] pub fn is_data0 ( & self ) -> bool { * self == DTSEQR :: DATA0 } # [ doc = "Checks if the value of the field is `DATA1`" ] # [ inline ] pub fn is_data1 ( & self ) -> bool { * self == DTSEQR :: DATA1 } } # [ doc = "Possible values of the field `NBUSYBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBUSYBKR { # [ doc = "0 busy bank (all banks free)" ] _0_BUSY , # [ doc = "1 busy bank" ] _1_BUSY , # [ doc = "2 busy banks" ] _2_BUSY , # [ doc = "3 busy banks" ] _3_BUSY } impl NBUSYBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBUSYBKR :: _0_BUSY => 0 , NBUSYBKR :: _1_BUSY => 0x01 , NBUSYBKR :: _2_BUSY => 0x02 , NBUSYBKR :: _3_BUSY => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBUSYBKR { match value { 0 => NBUSYBKR :: _0_BUSY , 1 => NBUSYBKR :: _1_BUSY , 2 => NBUSYBKR :: _2_BUSY , 3 => NBUSYBKR :: _3_BUSY , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_0_BUSY`" ] # [ inline ] pub fn is_0_busy ( & self ) -> bool { * self == NBUSYBKR :: _0_BUSY } # [ doc = "Checks if the value of the field is `_1_BUSY`" ] # [ inline ] pub fn is_1_busy ( & self ) -> bool { * self == NBUSYBKR :: _1_BUSY } # [ doc = "Checks if the value of the field is `_2_BUSY`" ] # [ inline ] pub fn is_2_busy ( & self ) -> bool { * self == NBUSYBKR :: _2_BUSY } # [ doc = "Checks if the value of the field is `_3_BUSY`" ] # [ inline ] pub fn is_3_busy ( & self ) -> bool { * self == NBUSYBKR :: _3_BUSY } } # [ doc = "Possible values of the field `CURRBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CURRBKR { # [ doc = "Current bank is bank0" ] BANK0 , # [ doc = "Current bank is bank1" ] BANK1 , # [ doc = "Current bank is bank2" ] BANK2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CURRBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CURRBKR :: BANK0 => 0 , CURRBKR :: BANK1 => 0x01 , CURRBKR :: BANK2 => 0x02 , CURRBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CURRBKR { match value { 0 => CURRBKR :: BANK0 , 1 => CURRBKR :: BANK1 , 2 => CURRBKR :: BANK2 , i => CURRBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BANK0`" ] # [ inline ] pub fn is_bank0 ( & self ) -> bool { * self == CURRBKR :: BANK0 } # [ doc = "Checks if the value of the field is `BANK1`" ] # [ inline ] pub fn is_bank1 ( & self ) -> bool { * self == CURRBKR :: BANK1 } # [ doc = "Checks if the value of the field is `BANK2`" ] # [ inline ] pub fn is_bank2 ( & self ) -> bool { * self == CURRBKR :: BANK2 } } # [ doc = r" Value of the field" ] pub struct RWALLR { bits : bool , } impl RWALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFGOKR { bits : bool , } impl CFGOKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PBYCTR { bits : u16 , } impl PBYCTR { # [ 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 = "Bit 0 - Received IN Data Interrupt" ] # [ inline ] pub fn rxini ( & self ) -> RXINIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXINIR { bits } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt" ] # [ inline ] pub fn txouti ( & self ) -> TXOUTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXOUTIR { bits } } # [ doc = "Bit 2 - Underflow Interrupt" ] # [ inline ] pub fn underfi ( & self ) -> UNDERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDERFIR { bits } } # [ doc = "Bit 3 - Pipe Error Interrupt" ] # [ inline ] pub fn perri ( & self ) -> PERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PERRIR { bits } } # [ doc = "Bit 4 - NAKed Interrupt" ] # [ inline ] pub fn nakedi ( & self ) -> NAKEDIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKEDIR { bits } } # [ doc = "Bit 5 - Overflow Interrupt" ] # [ inline ] pub fn overfi ( & self ) -> OVERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIR { bits } } # [ doc = "Bit 6 - Received STALLed Interrupt" ] # [ inline ] pub fn rxstalldi ( & self ) -> RXSTALLDIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSTALLDIR { bits } } # [ doc = "Bit 7 - Short Packet Interrupt" ] # [ inline ] pub fn shortpacketi ( & self ) -> SHORTPACKETIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETIR { bits } } # [ doc = "Bits 8:9 - Data Toggle Sequence" ] # [ inline ] pub fn dtseq ( & self ) -> DTSEQR { DTSEQR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Busy Banks" ] # [ inline ] pub fn nbusybk ( & self ) -> NBUSYBKR { NBUSYBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Current Bank" ] # [ inline ] pub fn currbk ( & self ) -> CURRBKR { CURRBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Read-write Allowed" ] # [ inline ] pub fn rwall ( & self ) -> RWALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RWALLR { bits } } # [ doc = "Bit 18 - Configuration OK Status" ] # [ inline ] pub fn cfgok ( & self ) -> CFGOKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFGOKR { bits } } # [ doc = "Bits 20:30 - Pipe Byte Count" ] # [ inline ] pub fn pbyct ( & self ) -> PBYCTR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; PBYCTR { bits } } } } # [ doc = "Host Pipe Status Register (n = 0)" ] pub struct HSTPIPISR0_ISOPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Status Register (n = 0)" ] pub mod hstpipisr0_isopipes { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTPIPISR0_ISOPIPES { # [ 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 RXINIR { bits : bool , } impl RXINIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXOUTIR { bits : bool , } impl TXOUTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDERFIR { bits : bool , } impl UNDERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PERRIR { bits : bool , } impl PERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKEDIR { bits : bool , } impl NAKEDIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIR { bits : bool , } impl OVERFIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CRCERRIR { bits : bool , } impl CRCERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETIR { bits : bool , } impl SHORTPACKETIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DTSEQ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DTSEQR { # [ doc = "Data0 toggle sequence" ] DATA0 , # [ doc = "Data1 toggle sequence" ] DATA1 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DTSEQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DTSEQR :: DATA0 => 0 , DTSEQR :: DATA1 => 0x01 , DTSEQR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DTSEQR { match value { 0 => DTSEQR :: DATA0 , 1 => DTSEQR :: DATA1 , i => DTSEQR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DATA0`" ] # [ inline ] pub fn is_data0 ( & self ) -> bool { * self == DTSEQR :: DATA0 } # [ doc = "Checks if the value of the field is `DATA1`" ] # [ inline ] pub fn is_data1 ( & self ) -> bool { * self == DTSEQR :: DATA1 } } # [ doc = "Possible values of the field `NBUSYBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NBUSYBKR { # [ doc = "0 busy bank (all banks free)" ] _0_BUSY , # [ doc = "1 busy bank" ] _1_BUSY , # [ doc = "2 busy banks" ] _2_BUSY , # [ doc = "3 busy banks" ] _3_BUSY } impl NBUSYBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NBUSYBKR :: _0_BUSY => 0 , NBUSYBKR :: _1_BUSY => 0x01 , NBUSYBKR :: _2_BUSY => 0x02 , NBUSYBKR :: _3_BUSY => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NBUSYBKR { match value { 0 => NBUSYBKR :: _0_BUSY , 1 => NBUSYBKR :: _1_BUSY , 2 => NBUSYBKR :: _2_BUSY , 3 => NBUSYBKR :: _3_BUSY , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_0_BUSY`" ] # [ inline ] pub fn is_0_busy ( & self ) -> bool { * self == NBUSYBKR :: _0_BUSY } # [ doc = "Checks if the value of the field is `_1_BUSY`" ] # [ inline ] pub fn is_1_busy ( & self ) -> bool { * self == NBUSYBKR :: _1_BUSY } # [ doc = "Checks if the value of the field is `_2_BUSY`" ] # [ inline ] pub fn is_2_busy ( & self ) -> bool { * self == NBUSYBKR :: _2_BUSY } # [ doc = "Checks if the value of the field is `_3_BUSY`" ] # [ inline ] pub fn is_3_busy ( & self ) -> bool { * self == NBUSYBKR :: _3_BUSY } } # [ doc = "Possible values of the field `CURRBK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CURRBKR { # [ doc = "Current bank is bank0" ] BANK0 , # [ doc = "Current bank is bank1" ] BANK1 , # [ doc = "Current bank is bank2" ] BANK2 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CURRBKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CURRBKR :: BANK0 => 0 , CURRBKR :: BANK1 => 0x01 , CURRBKR :: BANK2 => 0x02 , CURRBKR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CURRBKR { match value { 0 => CURRBKR :: BANK0 , 1 => CURRBKR :: BANK1 , 2 => CURRBKR :: BANK2 , i => CURRBKR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BANK0`" ] # [ inline ] pub fn is_bank0 ( & self ) -> bool { * self == CURRBKR :: BANK0 } # [ doc = "Checks if the value of the field is `BANK1`" ] # [ inline ] pub fn is_bank1 ( & self ) -> bool { * self == CURRBKR :: BANK1 } # [ doc = "Checks if the value of the field is `BANK2`" ] # [ inline ] pub fn is_bank2 ( & self ) -> bool { * self == CURRBKR :: BANK2 } } # [ doc = r" Value of the field" ] pub struct RWALLR { bits : bool , } impl RWALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFGOKR { bits : bool , } impl CFGOKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PBYCTR { bits : u16 , } impl PBYCTR { # [ 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 = "Bit 0 - Received IN Data Interrupt" ] # [ inline ] pub fn rxini ( & self ) -> RXINIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXINIR { bits } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt" ] # [ inline ] pub fn txouti ( & self ) -> TXOUTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXOUTIR { bits } } # [ doc = "Bit 2 - Underflow Interrupt" ] # [ inline ] pub fn underfi ( & self ) -> UNDERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDERFIR { bits } } # [ doc = "Bit 3 - Pipe Error Interrupt" ] # [ inline ] pub fn perri ( & self ) -> PERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PERRIR { bits } } # [ doc = "Bit 4 - NAKed Interrupt" ] # [ inline ] pub fn nakedi ( & self ) -> NAKEDIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKEDIR { bits } } # [ doc = "Bit 5 - Overflow Interrupt" ] # [ inline ] pub fn overfi ( & self ) -> OVERFIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIR { bits } } # [ doc = "Bit 6 - CRC Error Interrupt" ] # [ inline ] pub fn crcerri ( & self ) -> CRCERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CRCERRIR { bits } } # [ doc = "Bit 7 - Short Packet Interrupt" ] # [ inline ] pub fn shortpacketi ( & self ) -> SHORTPACKETIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETIR { bits } } # [ doc = "Bits 8:9 - Data Toggle Sequence" ] # [ inline ] pub fn dtseq ( & self ) -> DTSEQR { DTSEQR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:13 - Number of Busy Banks" ] # [ inline ] pub fn nbusybk ( & self ) -> NBUSYBKR { NBUSYBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Current Bank" ] # [ inline ] pub fn currbk ( & self ) -> CURRBKR { CURRBKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Read-write Allowed" ] # [ inline ] pub fn rwall ( & self ) -> RWALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RWALLR { bits } } # [ doc = "Bit 18 - Configuration OK Status" ] # [ inline ] pub fn cfgok ( & self ) -> CFGOKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFGOKR { bits } } # [ doc = "Bits 20:30 - Pipe Byte Count" ] # [ inline ] pub fn pbyct ( & self ) -> PBYCTR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; PBYCTR { bits } } } } # [ doc = "Host Pipe Clear Register (n = 0)" ] pub struct HSTPIPICR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Clear Register (n = 0)" ] pub mod hstpipicr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPICR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINICW < 'a > { w : & 'a mut W , } impl < 'a > _RXINICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTICW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXSTPICW < 'a > { w : & 'a mut W , } impl < 'a > _TXSTPICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDICW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFICW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDICW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETICW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Received IN Data Interrupt Clear" ] # [ inline ] pub fn rxinic ( & mut self ) -> _RXINICW { _RXINICW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Clear" ] # [ inline ] pub fn txoutic ( & mut self ) -> _TXOUTICW { _TXOUTICW { w : self } } # [ doc = "Bit 2 - Transmitted SETUP Interrupt Clear" ] # [ inline ] pub fn txstpic ( & mut self ) -> _TXSTPICW { _TXSTPICW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Clear" ] # [ inline ] pub fn nakedic ( & mut self ) -> _NAKEDICW { _NAKEDICW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Clear" ] # [ inline ] pub fn overfic ( & mut self ) -> _OVERFICW { _OVERFICW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Clear" ] # [ inline ] pub fn rxstalldic ( & mut self ) -> _RXSTALLDICW { _RXSTALLDICW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Clear" ] # [ inline ] pub fn shortpacketic ( & mut self ) -> _SHORTPACKETICW { _SHORTPACKETICW { w : self } } } } # [ doc = "Host Pipe Clear Register (n = 0)" ] pub struct HSTPIPICR0_INTPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Clear Register (n = 0)" ] pub mod hstpipicr0_intpipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPICR0_INTPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINICW < 'a > { w : & 'a mut W , } impl < 'a > _RXINICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTICW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFICW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDICW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFICW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDICW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETICW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Received IN Data Interrupt Clear" ] # [ inline ] pub fn rxinic ( & mut self ) -> _RXINICW { _RXINICW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Clear" ] # [ inline ] pub fn txoutic ( & mut self ) -> _TXOUTICW { _TXOUTICW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Clear" ] # [ inline ] pub fn underfic ( & mut self ) -> _UNDERFICW { _UNDERFICW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Clear" ] # [ inline ] pub fn nakedic ( & mut self ) -> _NAKEDICW { _NAKEDICW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Clear" ] # [ inline ] pub fn overfic ( & mut self ) -> _OVERFICW { _OVERFICW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Clear" ] # [ inline ] pub fn rxstalldic ( & mut self ) -> _RXSTALLDICW { _RXSTALLDICW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Clear" ] # [ inline ] pub fn shortpacketic ( & mut self ) -> _SHORTPACKETICW { _SHORTPACKETICW { w : self } } } } # [ doc = "Host Pipe Clear Register (n = 0)" ] pub struct HSTPIPICR0_ISOPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Clear Register (n = 0)" ] pub mod hstpipicr0_isopipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPICR0_ISOPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINICW < 'a > { w : & 'a mut W , } impl < 'a > _RXINICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTICW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFICW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDICW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFICW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRICW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETICW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Received IN Data Interrupt Clear" ] # [ inline ] pub fn rxinic ( & mut self ) -> _RXINICW { _RXINICW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Clear" ] # [ inline ] pub fn txoutic ( & mut self ) -> _TXOUTICW { _TXOUTICW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Clear" ] # [ inline ] pub fn underfic ( & mut self ) -> _UNDERFICW { _UNDERFICW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Clear" ] # [ inline ] pub fn nakedic ( & mut self ) -> _NAKEDICW { _NAKEDICW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Clear" ] # [ inline ] pub fn overfic ( & mut self ) -> _OVERFICW { _OVERFICW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Clear" ] # [ inline ] pub fn crcerric ( & mut self ) -> _CRCERRICW { _CRCERRICW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Clear" ] # [ inline ] pub fn shortpacketic ( & mut self ) -> _SHORTPACKETICW { _SHORTPACKETICW { w : self } } } } # [ doc = "Host Pipe Set Register (n = 0)" ] pub struct HSTPIPIFR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Set Register (n = 0)" ] pub mod hstpipifr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIFR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINISW < 'a > { w : & 'a mut W , } impl < 'a > _RXINISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTISW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXSTPISW < 'a > { w : & 'a mut W , } impl < 'a > _TXSTPISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRISW < 'a > { w : & 'a mut W , } impl < 'a > _PERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDISW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFISW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETISW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKSW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Received IN Data Interrupt Set" ] # [ inline ] pub fn rxinis ( & mut self ) -> _RXINISW { _RXINISW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Set" ] # [ inline ] pub fn txoutis ( & mut self ) -> _TXOUTISW { _TXOUTISW { w : self } } # [ doc = "Bit 2 - Transmitted SETUP Interrupt Set" ] # [ inline ] pub fn txstpis ( & mut self ) -> _TXSTPISW { _TXSTPISW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Set" ] # [ inline ] pub fn perris ( & mut self ) -> _PERRISW { _PERRISW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Set" ] # [ inline ] pub fn nakedis ( & mut self ) -> _NAKEDISW { _NAKEDISW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Set" ] # [ inline ] pub fn overfis ( & mut self ) -> _OVERFISW { _OVERFISW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Set" ] # [ inline ] pub fn rxstalldis ( & mut self ) -> _RXSTALLDISW { _RXSTALLDISW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Set" ] # [ inline ] pub fn shortpacketis ( & mut self ) -> _SHORTPACKETISW { _SHORTPACKETISW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Set" ] # [ inline ] pub fn nbusybks ( & mut self ) -> _NBUSYBKSW { _NBUSYBKSW { w : self } } } } # [ doc = "Host Pipe Set Register (n = 0)" ] pub struct HSTPIPIFR0_INTPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Set Register (n = 0)" ] pub mod hstpipifr0_intpipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIFR0_INTPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINISW < 'a > { w : & 'a mut W , } impl < 'a > _RXINISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTISW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFISW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRISW < 'a > { w : & 'a mut W , } impl < 'a > _PERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDISW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFISW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETISW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKSW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Received IN Data Interrupt Set" ] # [ inline ] pub fn rxinis ( & mut self ) -> _RXINISW { _RXINISW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Set" ] # [ inline ] pub fn txoutis ( & mut self ) -> _TXOUTISW { _TXOUTISW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Set" ] # [ inline ] pub fn underfis ( & mut self ) -> _UNDERFISW { _UNDERFISW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Set" ] # [ inline ] pub fn perris ( & mut self ) -> _PERRISW { _PERRISW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Set" ] # [ inline ] pub fn nakedis ( & mut self ) -> _NAKEDISW { _NAKEDISW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Set" ] # [ inline ] pub fn overfis ( & mut self ) -> _OVERFISW { _OVERFISW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Set" ] # [ inline ] pub fn rxstalldis ( & mut self ) -> _RXSTALLDISW { _RXSTALLDISW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Set" ] # [ inline ] pub fn shortpacketis ( & mut self ) -> _SHORTPACKETISW { _SHORTPACKETISW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Set" ] # [ inline ] pub fn nbusybks ( & mut self ) -> _NBUSYBKSW { _NBUSYBKSW { w : self } } } } # [ doc = "Host Pipe Set Register (n = 0)" ] pub struct HSTPIPIFR0_ISOPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Set Register (n = 0)" ] pub mod hstpipifr0_isopipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIFR0_ISOPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINISW < 'a > { w : & 'a mut W , } impl < 'a > _RXINISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTISW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFISW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRISW < 'a > { w : & 'a mut W , } impl < 'a > _PERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDISW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFISW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRISW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETISW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKSW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Received IN Data Interrupt Set" ] # [ inline ] pub fn rxinis ( & mut self ) -> _RXINISW { _RXINISW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Set" ] # [ inline ] pub fn txoutis ( & mut self ) -> _TXOUTISW { _TXOUTISW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Set" ] # [ inline ] pub fn underfis ( & mut self ) -> _UNDERFISW { _UNDERFISW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Set" ] # [ inline ] pub fn perris ( & mut self ) -> _PERRISW { _PERRISW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Set" ] # [ inline ] pub fn nakedis ( & mut self ) -> _NAKEDISW { _NAKEDISW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Set" ] # [ inline ] pub fn overfis ( & mut self ) -> _OVERFISW { _OVERFISW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Set" ] # [ inline ] pub fn crcerris ( & mut self ) -> _CRCERRISW { _CRCERRISW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Set" ] # [ inline ] pub fn shortpacketis ( & mut self ) -> _SHORTPACKETISW { _SHORTPACKETISW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Set" ] # [ inline ] pub fn nbusybks ( & mut self ) -> _NBUSYBKSW { _NBUSYBKSW { w : self } } } } # [ doc = "Host Pipe Mask Register (n = 0)" ] pub struct HSTPIPIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Mask Register (n = 0)" ] pub mod hstpipimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTPIPIMR { # [ 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 RXINER { bits : bool , } impl RXINER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXOUTER { bits : bool , } impl TXOUTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXSTPER { bits : bool , } impl TXSTPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PERRER { bits : bool , } impl PERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKEDER { bits : bool , } impl NAKEDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIER { bits : bool , } impl OVERFIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSTALLDER { bits : bool , } impl RXSTALLDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETIER { bits : bool , } impl SHORTPACKETIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NBUSYBKER { bits : bool , } impl NBUSYBKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FIFOCONR { bits : bool , } impl FIFOCONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PDISHDMAR { bits : bool , } impl PDISHDMAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PFREEZER { bits : bool , } impl PFREEZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSTDTR { bits : bool , } impl RSTDTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Received IN Data Interrupt Enable" ] # [ inline ] pub fn rxine ( & self ) -> RXINER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXINER { bits } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Enable" ] # [ inline ] pub fn txoute ( & self ) -> TXOUTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXOUTER { bits } } # [ doc = "Bit 2 - Transmitted SETUP Interrupt Enable" ] # [ inline ] pub fn txstpe ( & self ) -> TXSTPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXSTPER { bits } } # [ doc = "Bit 3 - Pipe Error Interrupt Enable" ] # [ inline ] pub fn perre ( & self ) -> PERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PERRER { bits } } # [ doc = "Bit 4 - NAKed Interrupt Enable" ] # [ inline ] pub fn nakede ( & self ) -> NAKEDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKEDER { bits } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfie ( & self ) -> OVERFIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIER { bits } } # [ doc = "Bit 6 - Received STALLed Interrupt Enable" ] # [ inline ] pub fn rxstallde ( & self ) -> RXSTALLDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSTALLDER { bits } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketie ( & self ) -> SHORTPACKETIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETIER { bits } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Enable" ] # [ inline ] pub fn nbusybke ( & self ) -> NBUSYBKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NBUSYBKER { bits } } # [ doc = "Bit 14 - FIFO Control" ] # [ inline ] pub fn fifocon ( & self ) -> FIFOCONR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOCONR { bits } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn pdishdma ( & self ) -> PDISHDMAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PDISHDMAR { bits } } # [ doc = "Bit 17 - Pipe Freeze" ] # [ inline ] pub fn pfreeze ( & self ) -> PFREEZER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PFREEZER { bits } } # [ doc = "Bit 18 - Reset Data Toggle" ] # [ inline ] pub fn rstdt ( & self ) -> RSTDTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSTDTR { bits } } } } # [ doc = "Host Pipe Mask Register (n = 0)" ] pub struct HSTPIPIMR0_INTPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Mask Register (n = 0)" ] pub mod hstpipimr0_intpipes { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTPIPIMR0_INTPIPES { # [ 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 RXINER { bits : bool , } impl RXINER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXOUTER { bits : bool , } impl TXOUTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDERFIER { bits : bool , } impl UNDERFIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PERRER { bits : bool , } impl PERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKEDER { bits : bool , } impl NAKEDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIER { bits : bool , } impl OVERFIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXSTALLDER { bits : bool , } impl RXSTALLDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETIER { bits : bool , } impl SHORTPACKETIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NBUSYBKER { bits : bool , } impl NBUSYBKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FIFOCONR { bits : bool , } impl FIFOCONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PDISHDMAR { bits : bool , } impl PDISHDMAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PFREEZER { bits : bool , } impl PFREEZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSTDTR { bits : bool , } impl RSTDTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Received IN Data Interrupt Enable" ] # [ inline ] pub fn rxine ( & self ) -> RXINER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXINER { bits } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Enable" ] # [ inline ] pub fn txoute ( & self ) -> TXOUTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXOUTER { bits } } # [ doc = "Bit 2 - Underflow Interrupt Enable" ] # [ inline ] pub fn underfie ( & self ) -> UNDERFIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDERFIER { bits } } # [ doc = "Bit 3 - Pipe Error Interrupt Enable" ] # [ inline ] pub fn perre ( & self ) -> PERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PERRER { bits } } # [ doc = "Bit 4 - NAKed Interrupt Enable" ] # [ inline ] pub fn nakede ( & self ) -> NAKEDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKEDER { bits } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfie ( & self ) -> OVERFIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIER { bits } } # [ doc = "Bit 6 - Received STALLed Interrupt Enable" ] # [ inline ] pub fn rxstallde ( & self ) -> RXSTALLDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXSTALLDER { bits } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketie ( & self ) -> SHORTPACKETIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETIER { bits } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Enable" ] # [ inline ] pub fn nbusybke ( & self ) -> NBUSYBKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NBUSYBKER { bits } } # [ doc = "Bit 14 - FIFO Control" ] # [ inline ] pub fn fifocon ( & self ) -> FIFOCONR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOCONR { bits } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn pdishdma ( & self ) -> PDISHDMAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PDISHDMAR { bits } } # [ doc = "Bit 17 - Pipe Freeze" ] # [ inline ] pub fn pfreeze ( & self ) -> PFREEZER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PFREEZER { bits } } # [ doc = "Bit 18 - Reset Data Toggle" ] # [ inline ] pub fn rstdt ( & self ) -> RSTDTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSTDTR { bits } } } } # [ doc = "Host Pipe Mask Register (n = 0)" ] pub struct HSTPIPIMR0_ISOPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Mask Register (n = 0)" ] pub mod hstpipimr0_isopipes { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: HSTPIPIMR0_ISOPIPES { # [ 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 RXINER { bits : bool , } impl RXINER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXOUTER { bits : bool , } impl TXOUTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDERFIER { bits : bool , } impl UNDERFIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PERRER { bits : bool , } impl PERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NAKEDER { bits : bool , } impl NAKEDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVERFIER { bits : bool , } impl OVERFIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CRCERRER { bits : bool , } impl CRCERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SHORTPACKETIER { bits : bool , } impl SHORTPACKETIER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NBUSYBKER { bits : bool , } impl NBUSYBKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FIFOCONR { bits : bool , } impl FIFOCONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PDISHDMAR { bits : bool , } impl PDISHDMAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PFREEZER { bits : bool , } impl PFREEZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSTDTR { bits : bool , } impl RSTDTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Received IN Data Interrupt Enable" ] # [ inline ] pub fn rxine ( & self ) -> RXINER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXINER { bits } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Enable" ] # [ inline ] pub fn txoute ( & self ) -> TXOUTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXOUTER { bits } } # [ doc = "Bit 2 - Underflow Interrupt Enable" ] # [ inline ] pub fn underfie ( & self ) -> UNDERFIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDERFIER { bits } } # [ doc = "Bit 3 - Pipe Error Interrupt Enable" ] # [ inline ] pub fn perre ( & self ) -> PERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PERRER { bits } } # [ doc = "Bit 4 - NAKed Interrupt Enable" ] # [ inline ] pub fn nakede ( & self ) -> NAKEDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NAKEDER { bits } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfie ( & self ) -> OVERFIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVERFIER { bits } } # [ doc = "Bit 6 - CRC Error Interrupt Enable" ] # [ inline ] pub fn crcerre ( & self ) -> CRCERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CRCERRER { bits } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketie ( & self ) -> SHORTPACKETIER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SHORTPACKETIER { bits } } # [ doc = "Bit 12 - Number of Busy Banks Interrupt Enable" ] # [ inline ] pub fn nbusybke ( & self ) -> NBUSYBKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NBUSYBKER { bits } } # [ doc = "Bit 14 - FIFO Control" ] # [ inline ] pub fn fifocon ( & self ) -> FIFOCONR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FIFOCONR { bits } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn pdishdma ( & self ) -> PDISHDMAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PDISHDMAR { bits } } # [ doc = "Bit 17 - Pipe Freeze" ] # [ inline ] pub fn pfreeze ( & self ) -> PFREEZER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PFREEZER { bits } } # [ doc = "Bit 18 - Reset Data Toggle" ] # [ inline ] pub fn rstdt ( & self ) -> RSTDTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSTDTR { bits } } } } # [ doc = "Host Pipe Enable Register (n = 0)" ] pub struct HSTPIPIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Enable Register (n = 0)" ] pub mod hstpipier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINESW < 'a > { w : & 'a mut W , } impl < 'a > _RXINESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTESW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXSTPESW < 'a > { w : & 'a mut W , } impl < 'a > _TXSTPESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRESW < 'a > { w : & 'a mut W , } impl < 'a > _PERRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDESW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFIESW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDESW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETIESW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKESW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PDISHDMASW < 'a > { w : & 'a mut W , } impl < 'a > _PDISHDMASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFREEZESW < 'a > { w : & 'a mut W , } impl < 'a > _PFREEZESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTDTSW < 'a > { w : & 'a mut W , } impl < 'a > _RSTDTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Received IN Data Interrupt Enable" ] # [ inline ] pub fn rxines ( & mut self ) -> _RXINESW { _RXINESW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Enable" ] # [ inline ] pub fn txoutes ( & mut self ) -> _TXOUTESW { _TXOUTESW { w : self } } # [ doc = "Bit 2 - Transmitted SETUP Interrupt Enable" ] # [ inline ] pub fn txstpes ( & mut self ) -> _TXSTPESW { _TXSTPESW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Enable" ] # [ inline ] pub fn perres ( & mut self ) -> _PERRESW { _PERRESW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Enable" ] # [ inline ] pub fn nakedes ( & mut self ) -> _NAKEDESW { _NAKEDESW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfies ( & mut self ) -> _OVERFIESW { _OVERFIESW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Enable" ] # [ inline ] pub fn rxstalldes ( & mut self ) -> _RXSTALLDESW { _RXSTALLDESW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketies ( & mut self ) -> _SHORTPACKETIESW { _SHORTPACKETIESW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Enable" ] # [ inline ] pub fn nbusybkes ( & mut self ) -> _NBUSYBKESW { _NBUSYBKESW { w : self } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn pdishdmas ( & mut self ) -> _PDISHDMASW { _PDISHDMASW { w : self } } # [ doc = "Bit 17 - Pipe Freeze Enable" ] # [ inline ] pub fn pfreezes ( & mut self ) -> _PFREEZESW { _PFREEZESW { w : self } } # [ doc = "Bit 18 - Reset Data Toggle Enable" ] # [ inline ] pub fn rstdts ( & mut self ) -> _RSTDTSW { _RSTDTSW { w : self } } } } # [ doc = "Host Pipe Enable Register (n = 0)" ] pub struct HSTPIPIER0_INTPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Enable Register (n = 0)" ] pub mod hstpipier0_intpipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIER0_INTPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINESW < 'a > { w : & 'a mut W , } impl < 'a > _RXINESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTESW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFIESW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRESW < 'a > { w : & 'a mut W , } impl < 'a > _PERRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDESW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFIESW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDESW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETIESW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKESW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PDISHDMASW < 'a > { w : & 'a mut W , } impl < 'a > _PDISHDMASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFREEZESW < 'a > { w : & 'a mut W , } impl < 'a > _PFREEZESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTDTSW < 'a > { w : & 'a mut W , } impl < 'a > _RSTDTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Received IN Data Interrupt Enable" ] # [ inline ] pub fn rxines ( & mut self ) -> _RXINESW { _RXINESW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Enable" ] # [ inline ] pub fn txoutes ( & mut self ) -> _TXOUTESW { _TXOUTESW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Enable" ] # [ inline ] pub fn underfies ( & mut self ) -> _UNDERFIESW { _UNDERFIESW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Enable" ] # [ inline ] pub fn perres ( & mut self ) -> _PERRESW { _PERRESW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Enable" ] # [ inline ] pub fn nakedes ( & mut self ) -> _NAKEDESW { _NAKEDESW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfies ( & mut self ) -> _OVERFIESW { _OVERFIESW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Enable" ] # [ inline ] pub fn rxstalldes ( & mut self ) -> _RXSTALLDESW { _RXSTALLDESW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketies ( & mut self ) -> _SHORTPACKETIESW { _SHORTPACKETIESW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Enable" ] # [ inline ] pub fn nbusybkes ( & mut self ) -> _NBUSYBKESW { _NBUSYBKESW { w : self } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn pdishdmas ( & mut self ) -> _PDISHDMASW { _PDISHDMASW { w : self } } # [ doc = "Bit 17 - Pipe Freeze Enable" ] # [ inline ] pub fn pfreezes ( & mut self ) -> _PFREEZESW { _PFREEZESW { w : self } } # [ doc = "Bit 18 - Reset Data Toggle Enable" ] # [ inline ] pub fn rstdts ( & mut self ) -> _RSTDTSW { _RSTDTSW { w : self } } } } # [ doc = "Host Pipe Enable Register (n = 0)" ] pub struct HSTPIPIER0_ISOPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Enable Register (n = 0)" ] pub mod hstpipier0_isopipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIER0_ISOPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINESW < 'a > { w : & 'a mut W , } impl < 'a > _RXINESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTESW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFIESW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRESW < 'a > { w : & 'a mut W , } impl < 'a > _PERRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDESW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFIESW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRESW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETIESW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETIESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKESW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PDISHDMASW < 'a > { w : & 'a mut W , } impl < 'a > _PDISHDMASW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFREEZESW < 'a > { w : & 'a mut W , } impl < 'a > _PFREEZESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTDTSW < 'a > { w : & 'a mut W , } impl < 'a > _RSTDTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Received IN Data Interrupt Enable" ] # [ inline ] pub fn rxines ( & mut self ) -> _RXINESW { _RXINESW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Enable" ] # [ inline ] pub fn txoutes ( & mut self ) -> _TXOUTESW { _TXOUTESW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Enable" ] # [ inline ] pub fn underfies ( & mut self ) -> _UNDERFIESW { _UNDERFIESW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Enable" ] # [ inline ] pub fn perres ( & mut self ) -> _PERRESW { _PERRESW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Enable" ] # [ inline ] pub fn nakedes ( & mut self ) -> _NAKEDESW { _NAKEDESW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Enable" ] # [ inline ] pub fn overfies ( & mut self ) -> _OVERFIESW { _OVERFIESW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Enable" ] # [ inline ] pub fn crcerres ( & mut self ) -> _CRCERRESW { _CRCERRESW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Enable" ] # [ inline ] pub fn shortpacketies ( & mut self ) -> _SHORTPACKETIESW { _SHORTPACKETIESW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Enable" ] # [ inline ] pub fn nbusybkes ( & mut self ) -> _NBUSYBKESW { _NBUSYBKESW { w : self } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Enable" ] # [ inline ] pub fn pdishdmas ( & mut self ) -> _PDISHDMASW { _PDISHDMASW { w : self } } # [ doc = "Bit 17 - Pipe Freeze Enable" ] # [ inline ] pub fn pfreezes ( & mut self ) -> _PFREEZESW { _PFREEZESW { w : self } } # [ doc = "Bit 18 - Reset Data Toggle Enable" ] # [ inline ] pub fn rstdts ( & mut self ) -> _RSTDTSW { _RSTDTSW { w : self } } } } # [ doc = "Host Pipe Disable Register (n = 0)" ] pub struct HSTPIPIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Disable Register (n = 0)" ] pub mod hstpipidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINECW < 'a > { w : & 'a mut W , } impl < 'a > _RXINECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTECW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXSTPECW < 'a > { w : & 'a mut W , } impl < 'a > _TXSTPECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRECW < 'a > { w : & 'a mut W , } impl < 'a > _PERRECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDECW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFIECW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDECW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETIECW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKECW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOCONCW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCONCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PDISHDMACW < 'a > { w : & 'a mut W , } impl < 'a > _PDISHDMACW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFREEZECW < 'a > { w : & 'a mut W , } impl < 'a > _PFREEZECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Received IN Data Interrupt Disable" ] # [ inline ] pub fn rxinec ( & mut self ) -> _RXINECW { _RXINECW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Disable" ] # [ inline ] pub fn txoutec ( & mut self ) -> _TXOUTECW { _TXOUTECW { w : self } } # [ doc = "Bit 2 - Transmitted SETUP Interrupt Disable" ] # [ inline ] pub fn txstpec ( & mut self ) -> _TXSTPECW { _TXSTPECW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Disable" ] # [ inline ] pub fn perrec ( & mut self ) -> _PERRECW { _PERRECW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Disable" ] # [ inline ] pub fn nakedec ( & mut self ) -> _NAKEDECW { _NAKEDECW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Disable" ] # [ inline ] pub fn overfiec ( & mut self ) -> _OVERFIECW { _OVERFIECW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Disable" ] # [ inline ] pub fn rxstalldec ( & mut self ) -> _RXSTALLDECW { _RXSTALLDECW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Disable" ] # [ inline ] pub fn shortpacketiec ( & mut self ) -> _SHORTPACKETIECW { _SHORTPACKETIECW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Disable" ] # [ inline ] pub fn nbusybkec ( & mut self ) -> _NBUSYBKECW { _NBUSYBKECW { w : self } } # [ doc = "Bit 14 - FIFO Control Disable" ] # [ inline ] pub fn fifoconc ( & mut self ) -> _FIFOCONCW { _FIFOCONCW { w : self } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Disable" ] # [ inline ] pub fn pdishdmac ( & mut self ) -> _PDISHDMACW { _PDISHDMACW { w : self } } # [ doc = "Bit 17 - Pipe Freeze Disable" ] # [ inline ] pub fn pfreezec ( & mut self ) -> _PFREEZECW { _PFREEZECW { w : self } } } } # [ doc = "Host Pipe Disable Register (n = 0)" ] pub struct HSTPIPIDR0_INTPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Disable Register (n = 0)" ] pub mod hstpipidr0_intpipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIDR0_INTPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINECW < 'a > { w : & 'a mut W , } impl < 'a > _RXINECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTECW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFIECW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRECW < 'a > { w : & 'a mut W , } impl < 'a > _PERRECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDECW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFIECW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXSTALLDECW < 'a > { w : & 'a mut W , } impl < 'a > _RXSTALLDECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETIECW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKECW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOCONCW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCONCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PDISHDMACW < 'a > { w : & 'a mut W , } impl < 'a > _PDISHDMACW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFREEZECW < 'a > { w : & 'a mut W , } impl < 'a > _PFREEZECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Received IN Data Interrupt Disable" ] # [ inline ] pub fn rxinec ( & mut self ) -> _RXINECW { _RXINECW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Disable" ] # [ inline ] pub fn txoutec ( & mut self ) -> _TXOUTECW { _TXOUTECW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Disable" ] # [ inline ] pub fn underfiec ( & mut self ) -> _UNDERFIECW { _UNDERFIECW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Disable" ] # [ inline ] pub fn perrec ( & mut self ) -> _PERRECW { _PERRECW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Disable" ] # [ inline ] pub fn nakedec ( & mut self ) -> _NAKEDECW { _NAKEDECW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Disable" ] # [ inline ] pub fn overfiec ( & mut self ) -> _OVERFIECW { _OVERFIECW { w : self } } # [ doc = "Bit 6 - Received STALLed Interrupt Disable" ] # [ inline ] pub fn rxstalldec ( & mut self ) -> _RXSTALLDECW { _RXSTALLDECW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Disable" ] # [ inline ] pub fn shortpacketiec ( & mut self ) -> _SHORTPACKETIECW { _SHORTPACKETIECW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Disable" ] # [ inline ] pub fn nbusybkec ( & mut self ) -> _NBUSYBKECW { _NBUSYBKECW { w : self } } # [ doc = "Bit 14 - FIFO Control Disable" ] # [ inline ] pub fn fifoconc ( & mut self ) -> _FIFOCONCW { _FIFOCONCW { w : self } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Disable" ] # [ inline ] pub fn pdishdmac ( & mut self ) -> _PDISHDMACW { _PDISHDMACW { w : self } } # [ doc = "Bit 17 - Pipe Freeze Disable" ] # [ inline ] pub fn pfreezec ( & mut self ) -> _PFREEZECW { _PFREEZECW { w : self } } } } # [ doc = "Host Pipe Disable Register (n = 0)" ] pub struct HSTPIPIDR0_ISOPIPES { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Disable Register (n = 0)" ] pub mod hstpipidr0_isopipes { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: HSTPIPIDR0_ISOPIPES { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXINECW < 'a > { w : & 'a mut W , } impl < 'a > _RXINECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXOUTECW < 'a > { w : & 'a mut W , } impl < 'a > _TXOUTECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDERFIECW < 'a > { w : & 'a mut W , } impl < 'a > _UNDERFIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRECW < 'a > { w : & 'a mut W , } impl < 'a > _PERRECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NAKEDECW < 'a > { w : & 'a mut W , } impl < 'a > _NAKEDECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVERFIECW < 'a > { w : & 'a mut W , } impl < 'a > _OVERFIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CRCERRECW < 'a > { w : & 'a mut W , } impl < 'a > _CRCERRECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SHORTPACKETIECW < 'a > { w : & 'a mut W , } impl < 'a > _SHORTPACKETIECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBUSYBKECW < 'a > { w : & 'a mut W , } impl < 'a > _NBUSYBKECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FIFOCONCW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCONCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PDISHDMACW < 'a > { w : & 'a mut W , } impl < 'a > _PDISHDMACW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFREEZECW < 'a > { w : & 'a mut W , } impl < 'a > _PFREEZECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Received IN Data Interrupt Disable" ] # [ inline ] pub fn rxinec ( & mut self ) -> _RXINECW { _RXINECW { w : self } } # [ doc = "Bit 1 - Transmitted OUT Data Interrupt Disable" ] # [ inline ] pub fn txoutec ( & mut self ) -> _TXOUTECW { _TXOUTECW { w : self } } # [ doc = "Bit 2 - Underflow Interrupt Disable" ] # [ inline ] pub fn underfiec ( & mut self ) -> _UNDERFIECW { _UNDERFIECW { w : self } } # [ doc = "Bit 3 - Pipe Error Interrupt Disable" ] # [ inline ] pub fn perrec ( & mut self ) -> _PERRECW { _PERRECW { w : self } } # [ doc = "Bit 4 - NAKed Interrupt Disable" ] # [ inline ] pub fn nakedec ( & mut self ) -> _NAKEDECW { _NAKEDECW { w : self } } # [ doc = "Bit 5 - Overflow Interrupt Disable" ] # [ inline ] pub fn overfiec ( & mut self ) -> _OVERFIECW { _OVERFIECW { w : self } } # [ doc = "Bit 6 - CRC Error Interrupt Disable" ] # [ inline ] pub fn crcerrec ( & mut self ) -> _CRCERRECW { _CRCERRECW { w : self } } # [ doc = "Bit 7 - Short Packet Interrupt Disable" ] # [ inline ] pub fn shortpacketiec ( & mut self ) -> _SHORTPACKETIECW { _SHORTPACKETIECW { w : self } } # [ doc = "Bit 12 - Number of Busy Banks Disable" ] # [ inline ] pub fn nbusybkec ( & mut self ) -> _NBUSYBKECW { _NBUSYBKECW { w : self } } # [ doc = "Bit 14 - FIFO Control Disable" ] # [ inline ] pub fn fifoconc ( & mut self ) -> _FIFOCONCW { _FIFOCONCW { w : self } } # [ doc = "Bit 16 - Pipe Interrupts Disable HDMA Request Disable" ] # [ inline ] pub fn pdishdmac ( & mut self ) -> _PDISHDMACW { _PDISHDMACW { w : self } } # [ doc = "Bit 17 - Pipe Freeze Disable" ] # [ inline ] pub fn pfreezec ( & mut self ) -> _PFREEZECW { _PFREEZECW { w : self } } } } # [ doc = "Host Pipe IN Request Register (n = 0)" ] pub struct HSTPIPINRQ { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe IN Request Register (n = 0)" ] pub mod hstpipinrq { # [ 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 :: HSTPIPINRQ { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 INRQR { bits : u8 , } impl INRQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct INMODER { bits : bool , } impl INMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _INRQW < 'a > { w : & 'a mut W , } impl < 'a > _INRQW < '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 _INMODEW < 'a > { w : & 'a mut W , } impl < 'a > _INMODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:7 - IN Request Number before Freeze" ] # [ inline ] pub fn inrq ( & self ) -> INRQR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; INRQR { bits } } # [ doc = "Bit 8 - IN Request Mode" ] # [ inline ] pub fn inmode ( & self ) -> INMODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INMODER { bits } } } impl W { # [ doc = "Bits 0:7 - IN Request Number before Freeze" ] # [ inline ] pub fn inrq ( & mut self ) -> _INRQW { _INRQW { w : self } } # [ doc = "Bit 8 - IN Request Mode" ] # [ inline ] pub fn inmode ( & mut self ) -> _INMODEW { _INMODEW { w : self } } } } # [ doc = "Host Pipe Error Register (n = 0)" ] pub struct HSTPIPERR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host Pipe Error Register (n = 0)" ] pub mod hstpiperr { # [ 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 :: HSTPIPERR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 DATATGLR { bits : bool , } impl DATATGLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DATAPIDR { bits : bool , } impl DATAPIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PIDR { bits : bool , } impl PIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 CRC16R { bits : bool , } impl CRC16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct COUNTERR { bits : u8 , } impl COUNTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _DATATGLW < 'a > { w : & 'a mut W , } impl < 'a > _DATATGLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DATAPIDW < 'a > { w : & 'a mut W , } impl < 'a > _DATAPIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PIDW < 'a > { w : & 'a mut W , } impl < 'a > _PIDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMEOUTW < 'a > { w : & 'a mut W , } impl < 'a > _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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _CRC16W < 'a > { w : & 'a mut W , } impl < 'a > _CRC16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _COUNTERW < 'a > { w : & 'a mut W , } impl < 'a > _COUNTERW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Data Toggle Error" ] # [ inline ] pub fn datatgl ( & self ) -> DATATGLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DATATGLR { bits } } # [ doc = "Bit 1 - Data PID Error" ] # [ inline ] pub fn datapid ( & self ) -> DATAPIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DATAPIDR { bits } } # [ doc = "Bit 2 - PID Error" ] # [ inline ] pub fn pid ( & self ) -> PIDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PIDR { bits } } # [ doc = "Bit 3 - Time-Out Error" ] # [ inline ] pub fn timeout ( & self ) -> TIMEOUTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMEOUTR { bits } } # [ doc = "Bit 4 - CRC16 Error" ] # [ inline ] pub fn crc16 ( & self ) -> CRC16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CRC16R { bits } } # [ doc = "Bits 5:6 - Error Counter" ] # [ inline ] pub fn counter ( & self ) -> COUNTERR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; COUNTERR { bits } } } impl W { # [ doc = "Bit 0 - Data Toggle Error" ] # [ inline ] pub fn datatgl ( & mut self ) -> _DATATGLW { _DATATGLW { w : self } } # [ doc = "Bit 1 - Data PID Error" ] # [ inline ] pub fn datapid ( & mut self ) -> _DATAPIDW { _DATAPIDW { w : self } } # [ doc = "Bit 2 - PID Error" ] # [ inline ] pub fn pid ( & mut self ) -> _PIDW { _PIDW { w : self } } # [ doc = "Bit 3 - Time-Out Error" ] # [ inline ] pub fn timeout ( & mut self ) -> _TIMEOUTW { _TIMEOUTW { w : self } } # [ doc = "Bit 4 - CRC16 Error" ] # [ inline ] pub fn crc16 ( & mut self ) -> _CRC16W { _CRC16W { w : self } } # [ doc = "Bits 5:6 - Error Counter" ] # [ inline ] pub fn counter ( & mut self ) -> _COUNTERW { _COUNTERW { w : self } } } } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 1)" ] pub struct HSTDMANXTDSC1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 1)" ] pub mod hstdmanxtdsc1 { # [ 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 :: HSTDMANXTDSC1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Host DMA Channel Address Register (n = 1)" ] pub struct HSTDMAADDRESS1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Address Register (n = 1)" ] pub mod hstdmaaddress1 { # [ 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 :: HSTDMAADDRESS1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Host DMA Channel Control Register (n = 1)" ] pub struct HSTDMACONTROL1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Control Register (n = 1)" ] pub mod hstdmacontrol1 { # [ 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 :: HSTDMACONTROL1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Host DMA Channel Status Register (n = 1)" ] pub struct HSTDMASTATUS1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Status Register (n = 1)" ] pub mod hstdmastatus1 { # [ 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 :: HSTDMASTATUS1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 2)" ] pub struct HSTDMANXTDSC2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 2)" ] pub mod hstdmanxtdsc2 { # [ 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 :: HSTDMANXTDSC2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Host DMA Channel Address Register (n = 2)" ] pub struct HSTDMAADDRESS2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Address Register (n = 2)" ] pub mod hstdmaaddress2 { # [ 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 :: HSTDMAADDRESS2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Host DMA Channel Control Register (n = 2)" ] pub struct HSTDMACONTROL2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Control Register (n = 2)" ] pub mod hstdmacontrol2 { # [ 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 :: HSTDMACONTROL2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Host DMA Channel Status Register (n = 2)" ] pub struct HSTDMASTATUS2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Status Register (n = 2)" ] pub mod hstdmastatus2 { # [ 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 :: HSTDMASTATUS2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 3)" ] pub struct HSTDMANXTDSC3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 3)" ] pub mod hstdmanxtdsc3 { # [ 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 :: HSTDMANXTDSC3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Host DMA Channel Address Register (n = 3)" ] pub struct HSTDMAADDRESS3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Address Register (n = 3)" ] pub mod hstdmaaddress3 { # [ 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 :: HSTDMAADDRESS3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Host DMA Channel Control Register (n = 3)" ] pub struct HSTDMACONTROL3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Control Register (n = 3)" ] pub mod hstdmacontrol3 { # [ 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 :: HSTDMACONTROL3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Host DMA Channel Status Register (n = 3)" ] pub struct HSTDMASTATUS3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Status Register (n = 3)" ] pub mod hstdmastatus3 { # [ 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 :: HSTDMASTATUS3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 4)" ] pub struct HSTDMANXTDSC4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 4)" ] pub mod hstdmanxtdsc4 { # [ 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 :: HSTDMANXTDSC4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Host DMA Channel Address Register (n = 4)" ] pub struct HSTDMAADDRESS4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Address Register (n = 4)" ] pub mod hstdmaaddress4 { # [ 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 :: HSTDMAADDRESS4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Host DMA Channel Control Register (n = 4)" ] pub struct HSTDMACONTROL4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Control Register (n = 4)" ] pub mod hstdmacontrol4 { # [ 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 :: HSTDMACONTROL4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Host DMA Channel Status Register (n = 4)" ] pub struct HSTDMASTATUS4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Status Register (n = 4)" ] pub mod hstdmastatus4 { # [ 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 :: HSTDMASTATUS4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 5)" ] pub struct HSTDMANXTDSC5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 5)" ] pub mod hstdmanxtdsc5 { # [ 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 :: HSTDMANXTDSC5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Host DMA Channel Address Register (n = 5)" ] pub struct HSTDMAADDRESS5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Address Register (n = 5)" ] pub mod hstdmaaddress5 { # [ 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 :: HSTDMAADDRESS5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Host DMA Channel Control Register (n = 5)" ] pub struct HSTDMACONTROL5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Control Register (n = 5)" ] pub mod hstdmacontrol5 { # [ 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 :: HSTDMACONTROL5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Host DMA Channel Status Register (n = 5)" ] pub struct HSTDMASTATUS5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Status Register (n = 5)" ] pub mod hstdmastatus5 { # [ 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 :: HSTDMASTATUS5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 6)" ] pub struct HSTDMANXTDSC6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 6)" ] pub mod hstdmanxtdsc6 { # [ 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 :: HSTDMANXTDSC6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Host DMA Channel Address Register (n = 6)" ] pub struct HSTDMAADDRESS6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Address Register (n = 6)" ] pub mod hstdmaaddress6 { # [ 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 :: HSTDMAADDRESS6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Host DMA Channel Control Register (n = 6)" ] pub struct HSTDMACONTROL6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Control Register (n = 6)" ] pub mod hstdmacontrol6 { # [ 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 :: HSTDMACONTROL6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Host DMA Channel Status Register (n = 6)" ] pub struct HSTDMASTATUS6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Status Register (n = 6)" ] pub mod hstdmastatus6 { # [ 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 :: HSTDMASTATUS6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 7)" ] pub struct HSTDMANXTDSC7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Next Descriptor Address Register (n = 7)" ] pub mod hstdmanxtdsc7 { # [ 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 :: HSTDMANXTDSC7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NXT_DSC_ADDR { bits : u32 , } impl NXT_DSC_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _NXT_DSC_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _NXT_DSC_ADDW < '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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & self ) -> NXT_DSC_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; NXT_DSC_ADDR { 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 - Next Descriptor Address" ] # [ inline ] pub fn nxt_dsc_add ( & mut self ) -> _NXT_DSC_ADDW { _NXT_DSC_ADDW { w : self } } } } # [ doc = "Host DMA Channel Address Register (n = 7)" ] pub struct HSTDMAADDRESS7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Address Register (n = 7)" ] pub mod hstdmaaddress7 { # [ 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 :: HSTDMAADDRESS7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BUFF_ADDR { bits : u32 , } impl BUFF_ADDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _BUFF_ADDW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_ADDW < '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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & self ) -> BUFF_ADDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; BUFF_ADDR { 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 - Buffer Address" ] # [ inline ] pub fn buff_add ( & mut self ) -> _BUFF_ADDW { _BUFF_ADDW { w : self } } } } # [ doc = "Host DMA Channel Control Register (n = 7)" ] pub struct HSTDMACONTROL7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Control Register (n = 7)" ] pub mod hstdmacontrol7 { # [ 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 :: HSTDMACONTROL7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LDNXT_DSCR { bits : bool , } impl LDNXT_DSCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_ENR { bits : bool , } impl END_TR_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 END_B_ENR { bits : bool , } impl END_B_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 END_TR_ITR { bits : bool , } impl END_TR_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BUFFITR { bits : bool , } impl END_BUFFITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LD_ITR { bits : bool , } impl DESC_LD_ITR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BURST_LCKR { bits : bool , } impl BURST_LCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_LENGTHR { bits : u16 , } impl BUFF_LENGTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LDNXT_DSCW < 'a > { w : & 'a mut W , } impl < 'a > _LDNXT_DSCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_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 = 2 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_B_ENW < 'a > { w : & 'a mut W , } impl < 'a > _END_B_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 = 3 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _END_TR_ITW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BUFFITW < 'a > { w : & 'a mut W , } impl < 'a > _END_BUFFITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LD_ITW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LD_ITW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BURST_LCKW < 'a > { w : & 'a mut W , } impl < 'a > _BURST_LCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_LENGTHW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_LENGTHW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Command" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & self ) -> LDNXT_DSCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LDNXT_DSCR { bits } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & self ) -> END_TR_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ENR { bits } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & self ) -> END_B_ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_B_ENR { bits } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & self ) -> END_TR_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_ITR { bits } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & self ) -> END_BUFFITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BUFFITR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & self ) -> DESC_LD_ITR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LD_ITR { bits } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & self ) -> BURST_LCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BURST_LCKR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & self ) -> BUFF_LENGTHR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_LENGTHR { 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 Command" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Load Next Channel Transfer Descriptor Enable Command" ] # [ inline ] pub fn ldnxt_dsc ( & mut self ) -> _LDNXT_DSCW { _LDNXT_DSCW { w : self } } # [ doc = "Bit 2 - End of Transfer Enable (Control)" ] # [ inline ] pub fn end_tr_en ( & mut self ) -> _END_TR_ENW { _END_TR_ENW { w : self } } # [ doc = "Bit 3 - End of Buffer Enable Control" ] # [ inline ] pub fn end_b_en ( & mut self ) -> _END_B_ENW { _END_B_ENW { w : self } } # [ doc = "Bit 4 - End of Transfer Interrupt Enable" ] # [ inline ] pub fn end_tr_it ( & mut self ) -> _END_TR_ITW { _END_TR_ITW { w : self } } # [ doc = "Bit 5 - End of Buffer Interrupt Enable" ] # [ inline ] pub fn end_buffit ( & mut self ) -> _END_BUFFITW { _END_BUFFITW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Interrupt Enable" ] # [ inline ] pub fn desc_ld_it ( & mut self ) -> _DESC_LD_ITW { _DESC_LD_ITW { w : self } } # [ doc = "Bit 7 - Burst Lock Enable" ] # [ inline ] pub fn burst_lck ( & mut self ) -> _BURST_LCKW { _BURST_LCKW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Length (Write-only)" ] # [ inline ] pub fn buff_length ( & mut self ) -> _BUFF_LENGTHW { _BUFF_LENGTHW { w : self } } } } # [ doc = "Host DMA Channel Status Register (n = 7)" ] pub struct HSTDMASTATUS7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Host DMA Channel Status Register (n = 7)" ] pub mod hstdmastatus7 { # [ 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 :: HSTDMASTATUS7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CHANN_ENBR { bits : bool , } impl CHANN_ENBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CHANN_ACTR { bits : bool , } impl CHANN_ACTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_TR_STR { bits : bool , } impl END_TR_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct END_BF_STR { bits : bool , } impl END_BF_STR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DESC_LDSTR { bits : bool , } impl DESC_LDSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BUFF_COUNTR { bits : u16 , } impl BUFF_COUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CHANN_ENBW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ENBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CHANN_ACTW < 'a > { w : & 'a mut W , } impl < 'a > _CHANN_ACTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_TR_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_TR_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _END_BF_STW < 'a > { w : & 'a mut W , } impl < 'a > _END_BF_STW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DESC_LDSTW < 'a > { w : & 'a mut W , } impl < 'a > _DESC_LDSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BUFF_COUNTW < 'a > { w : & 'a mut W , } impl < 'a > _BUFF_COUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Channel Enable Status" ] # [ inline ] pub fn chann_enb ( & self ) -> CHANN_ENBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ENBR { bits } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & self ) -> CHANN_ACTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CHANN_ACTR { bits } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & self ) -> END_TR_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_TR_STR { bits } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & self ) -> END_BF_STR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; END_BF_STR { bits } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & self ) -> DESC_LDSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DESC_LDSTR { bits } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & self ) -> BUFF_COUNTR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BUFF_COUNTR { 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 Status" ] # [ inline ] pub fn chann_enb ( & mut self ) -> _CHANN_ENBW { _CHANN_ENBW { w : self } } # [ doc = "Bit 1 - Channel Active Status" ] # [ inline ] pub fn chann_act ( & mut self ) -> _CHANN_ACTW { _CHANN_ACTW { w : self } } # [ doc = "Bit 4 - End of Channel Transfer Status" ] # [ inline ] pub fn end_tr_st ( & mut self ) -> _END_TR_STW { _END_TR_STW { w : self } } # [ doc = "Bit 5 - End of Channel Buffer Status" ] # [ inline ] pub fn end_bf_st ( & mut self ) -> _END_BF_STW { _END_BF_STW { w : self } } # [ doc = "Bit 6 - Descriptor Loaded Status" ] # [ inline ] pub fn desc_ldst ( & mut self ) -> _DESC_LDSTW { _DESC_LDSTW { w : self } } # [ doc = "Bits 16:31 - Buffer Byte Count" ] # [ inline ] pub fn buff_count ( & mut self ) -> _BUFF_COUNTW { _BUFF_COUNTW { w : self } } } } # [ doc = "General Control Register" ] pub struct CTRL { register : :: vcell :: VolatileCell < u32 > } # [ doc = "General Control Register" ] pub mod ctrl { # [ 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 :: CTRL { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 IDTER { bits : bool , } impl IDTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBUSTER { bits : bool , } impl VBUSTER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SRPER { bits : bool , } impl SRPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBERRER { bits : bool , } impl VBERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BCERRER { bits : bool , } impl BCERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ROLEEXER { bits : bool , } impl ROLEEXER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HNPERRER { bits : bool , } impl HNPERRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STOER { bits : bool , } impl STOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBUSHWCR { bits : bool , } impl VBUSHWCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SRPSELR { bits : bool , } impl SRPSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SRPREQR { bits : bool , } impl SRPREQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HNPREQR { bits : bool , } impl HNPREQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OTGPADER { bits : bool , } impl OTGPADER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBUSPOR { bits : bool , } impl VBUSPOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRZCLKR { bits : bool , } impl FRZCLKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct USBER { bits : bool , } impl USBER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TIMVALUER { bits : u8 , } impl TIMVALUER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TIMPAGER { bits : u8 , } impl TIMPAGER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct UNLOCKR { bits : bool , } impl UNLOCKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `UIDE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum UIDER { # [ doc = "The USB mode (device/host) is selected from the UIMOD bit." ] UIMOD , # [ doc = "The USB mode (device/host) is selected from the UOTGID input pin." ] UOTGID } impl UIDER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { UIDER :: UIMOD => false , UIDER :: UOTGID => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> UIDER { match value { false => UIDER :: UIMOD , true => UIDER :: UOTGID , } } # [ doc = "Checks if the value of the field is `UIMOD`" ] # [ inline ] pub fn is_uimod ( & self ) -> bool { * self == UIDER :: UIMOD } # [ doc = "Checks if the value of the field is `UOTGID`" ] # [ inline ] pub fn is_uotgid ( & self ) -> bool { * self == UIDER :: UOTGID } } # [ doc = "Possible values of the field `UIMOD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum UIMODR { # [ doc = "The module is in USB host mode." ] HOST , # [ doc = "The module is in USB device mode." ] DEVICE } impl UIMODR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { UIMODR :: HOST => false , UIMODR :: DEVICE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> UIMODR { match value { false => UIMODR :: HOST , true => UIMODR :: DEVICE , } } # [ doc = "Checks if the value of the field is `HOST`" ] # [ inline ] pub fn is_host ( & self ) -> bool { * self == UIMODR :: HOST } # [ doc = "Checks if the value of the field is `DEVICE`" ] # [ inline ] pub fn is_device ( & self ) -> bool { * self == UIMODR :: DEVICE } } # [ doc = r" Proxy" ] pub struct _IDTEW < 'a > { w : & 'a mut W , } impl < 'a > _IDTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBUSTEW < 'a > { w : & 'a mut W , } impl < 'a > _VBUSTEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SRPEW < 'a > { w : & 'a mut W , } impl < 'a > _SRPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBERREW < 'a > { w : & 'a mut W , } impl < 'a > _VBERREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BCERREW < 'a > { w : & 'a mut W , } impl < 'a > _BCERREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ROLEEXEW < 'a > { w : & 'a mut W , } impl < 'a > _ROLEEXEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HNPERREW < 'a > { w : & 'a mut W , } impl < 'a > _HNPERREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STOEW < 'a > { w : & 'a mut W , } impl < 'a > _STOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBUSHWCW < 'a > { w : & 'a mut W , } impl < 'a > _VBUSHWCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SRPSELW < 'a > { w : & 'a mut W , } impl < 'a > _SRPSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SRPREQW < 'a > { w : & 'a mut W , } impl < 'a > _SRPREQW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HNPREQW < 'a > { w : & 'a mut W , } impl < 'a > _HNPREQW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OTGPADEW < 'a > { w : & 'a mut W , } impl < 'a > _OTGPADEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBUSPOW < 'a > { w : & 'a mut W , } impl < 'a > _VBUSPOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRZCLKW < 'a > { w : & 'a mut W , } impl < 'a > _FRZCLKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _USBEW < 'a > { w : & 'a mut W , } impl < 'a > _USBEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMVALUEW < 'a > { w : & 'a mut W , } impl < 'a > _TIMVALUEW < '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 _TIMPAGEW < 'a > { w : & 'a mut W , } impl < 'a > _TIMPAGEW < '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 _UNLOCKW < 'a > { w : & 'a mut W , } impl < 'a > _UNLOCKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `UIDE`" ] pub enum UIDEW { # [ doc = "The USB mode (device/host) is selected from the UIMOD bit." ] UIMOD , # [ doc = "The USB mode (device/host) is selected from the UOTGID input pin." ] UOTGID } impl UIDEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { UIDEW :: UIMOD => false , UIDEW :: UOTGID => true } } } # [ doc = r" Proxy" ] pub struct _UIDEW < 'a > { w : & 'a mut W , } impl < 'a > _UIDEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : UIDEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The USB mode (device/host) is selected from the UIMOD bit." ] # [ inline ] pub fn uimod ( self ) -> & 'a mut W { self . variant ( UIDEW :: UIMOD ) } # [ doc = "The USB mode (device/host) is selected from the UOTGID input pin." ] # [ inline ] pub fn uotgid ( self ) -> & 'a mut W { self . variant ( UIDEW :: UOTGID ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `UIMOD`" ] pub enum UIMODW { # [ doc = "The module is in USB host mode." ] HOST , # [ doc = "The module is in USB device mode." ] DEVICE } impl UIMODW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { UIMODW :: HOST => false , UIMODW :: DEVICE => true } } } # [ doc = r" Proxy" ] pub struct _UIMODW < 'a > { w : & 'a mut W , } impl < 'a > _UIMODW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : UIMODW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The module is in USB host mode." ] # [ inline ] pub fn host ( self ) -> & 'a mut W { self . variant ( UIMODW :: HOST ) } # [ doc = "The module is in USB device mode." ] # [ inline ] pub fn device ( self ) -> & 'a mut W { self . variant ( UIMODW :: DEVICE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - ID Transition Interrupt Enable" ] # [ inline ] pub fn idte ( & self ) -> IDTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDTER { bits } } # [ doc = "Bit 1 - VBus Transition Interrupt Enable" ] # [ inline ] pub fn vbuste ( & self ) -> VBUSTER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBUSTER { bits } } # [ doc = "Bit 2 - SRP Interrupt Enable" ] # [ inline ] pub fn srpe ( & self ) -> SRPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SRPER { bits } } # [ doc = "Bit 3 - VBus Error Interrupt Enable" ] # [ inline ] pub fn vberre ( & self ) -> VBERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBERRER { bits } } # [ doc = "Bit 4 - B-Connection Error Interrupt Enable" ] # [ inline ] pub fn bcerre ( & self ) -> BCERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BCERRER { bits } } # [ doc = "Bit 5 - Role Exchange Interrupt Enable" ] # [ inline ] pub fn roleexe ( & self ) -> ROLEEXER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ROLEEXER { bits } } # [ doc = "Bit 6 - HNP Error Interrupt Enable" ] # [ inline ] pub fn hnperre ( & self ) -> HNPERRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HNPERRER { bits } } # [ doc = "Bit 7 - Suspend Time-Out Interrupt Enable" ] # [ inline ] pub fn stoe ( & self ) -> STOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STOER { bits } } # [ doc = "Bit 8 - VBus Hardware Control" ] # [ inline ] pub fn vbushwc ( & self ) -> VBUSHWCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBUSHWCR { bits } } # [ doc = "Bit 9 - SRP Selection" ] # [ inline ] pub fn srpsel ( & self ) -> SRPSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SRPSELR { bits } } # [ doc = "Bit 10 - SRP Request" ] # [ inline ] pub fn srpreq ( & self ) -> SRPREQR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SRPREQR { bits } } # [ doc = "Bit 11 - HNP Request" ] # [ inline ] pub fn hnpreq ( & self ) -> HNPREQR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HNPREQR { bits } } # [ doc = "Bit 12 - OTG Pad Enable" ] # [ inline ] pub fn otgpade ( & self ) -> OTGPADER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OTGPADER { bits } } # [ doc = "Bit 13 - VBus Polarity Off" ] # [ inline ] pub fn vbuspo ( & self ) -> VBUSPOR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBUSPOR { bits } } # [ doc = "Bit 14 - Freeze USB Clock" ] # [ inline ] pub fn frzclk ( & self ) -> FRZCLKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRZCLKR { bits } } # [ doc = "Bit 15 - UOTGHS Enable" ] # [ inline ] pub fn usbe ( & self ) -> USBER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; USBER { bits } } # [ doc = "Bits 16:17 - Timer Value" ] # [ inline ] pub fn timvalue ( & self ) -> TIMVALUER { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TIMVALUER { bits } } # [ doc = "Bits 20:21 - Timer Page" ] # [ inline ] pub fn timpage ( & self ) -> TIMPAGER { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TIMPAGER { bits } } # [ doc = "Bit 22 - Timer Access Unlock" ] # [ inline ] pub fn unlock ( & self ) -> UNLOCKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNLOCKR { bits } } # [ doc = "Bit 24 - UOTGID Pin Enable" ] # [ inline ] pub fn uide ( & self ) -> UIDER { UIDER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 25 - UOTGHS Mode" ] # [ inline ] pub fn uimod ( & self ) -> UIMODR { UIMODR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0300_4000 } } # [ 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 - ID Transition Interrupt Enable" ] # [ inline ] pub fn idte ( & mut self ) -> _IDTEW { _IDTEW { w : self } } # [ doc = "Bit 1 - VBus Transition Interrupt Enable" ] # [ inline ] pub fn vbuste ( & mut self ) -> _VBUSTEW { _VBUSTEW { w : self } } # [ doc = "Bit 2 - SRP Interrupt Enable" ] # [ inline ] pub fn srpe ( & mut self ) -> _SRPEW { _SRPEW { w : self } } # [ doc = "Bit 3 - VBus Error Interrupt Enable" ] # [ inline ] pub fn vberre ( & mut self ) -> _VBERREW { _VBERREW { w : self } } # [ doc = "Bit 4 - B-Connection Error Interrupt Enable" ] # [ inline ] pub fn bcerre ( & mut self ) -> _BCERREW { _BCERREW { w : self } } # [ doc = "Bit 5 - Role Exchange Interrupt Enable" ] # [ inline ] pub fn roleexe ( & mut self ) -> _ROLEEXEW { _ROLEEXEW { w : self } } # [ doc = "Bit 6 - HNP Error Interrupt Enable" ] # [ inline ] pub fn hnperre ( & mut self ) -> _HNPERREW { _HNPERREW { w : self } } # [ doc = "Bit 7 - Suspend Time-Out Interrupt Enable" ] # [ inline ] pub fn stoe ( & mut self ) -> _STOEW { _STOEW { w : self } } # [ doc = "Bit 8 - VBus Hardware Control" ] # [ inline ] pub fn vbushwc ( & mut self ) -> _VBUSHWCW { _VBUSHWCW { w : self } } # [ doc = "Bit 9 - SRP Selection" ] # [ inline ] pub fn srpsel ( & mut self ) -> _SRPSELW { _SRPSELW { w : self } } # [ doc = "Bit 10 - SRP Request" ] # [ inline ] pub fn srpreq ( & mut self ) -> _SRPREQW { _SRPREQW { w : self } } # [ doc = "Bit 11 - HNP Request" ] # [ inline ] pub fn hnpreq ( & mut self ) -> _HNPREQW { _HNPREQW { w : self } } # [ doc = "Bit 12 - OTG Pad Enable" ] # [ inline ] pub fn otgpade ( & mut self ) -> _OTGPADEW { _OTGPADEW { w : self } } # [ doc = "Bit 13 - VBus Polarity Off" ] # [ inline ] pub fn vbuspo ( & mut self ) -> _VBUSPOW { _VBUSPOW { w : self } } # [ doc = "Bit 14 - Freeze USB Clock" ] # [ inline ] pub fn frzclk ( & mut self ) -> _FRZCLKW { _FRZCLKW { w : self } } # [ doc = "Bit 15 - UOTGHS Enable" ] # [ inline ] pub fn usbe ( & mut self ) -> _USBEW { _USBEW { w : self } } # [ doc = "Bits 16:17 - Timer Value" ] # [ inline ] pub fn timvalue ( & mut self ) -> _TIMVALUEW { _TIMVALUEW { w : self } } # [ doc = "Bits 20:21 - Timer Page" ] # [ inline ] pub fn timpage ( & mut self ) -> _TIMPAGEW { _TIMPAGEW { w : self } } # [ doc = "Bit 22 - Timer Access Unlock" ] # [ inline ] pub fn unlock ( & mut self ) -> _UNLOCKW { _UNLOCKW { w : self } } # [ doc = "Bit 24 - UOTGID Pin Enable" ] # [ inline ] pub fn uide ( & mut self ) -> _UIDEW { _UIDEW { w : self } } # [ doc = "Bit 25 - UOTGHS Mode" ] # [ inline ] pub fn uimod ( & mut self ) -> _UIMODW { _UIMODW { w : self } } } } # [ doc = "General Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "General 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 IDTIR { bits : bool , } impl IDTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBUSTIR { bits : bool , } impl VBUSTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SRPIR { bits : bool , } impl SRPIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBERRIR { bits : bool , } impl VBERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BCERRIR { bits : bool , } impl BCERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ROLEEXIR { bits : bool , } impl ROLEEXIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HNPERRIR { bits : bool , } impl HNPERRIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STOIR { bits : bool , } impl STOIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBUSRQR { bits : bool , } impl VBUSRQR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct IDR { bits : bool , } impl IDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct VBUSR { bits : bool , } impl VBUSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `SPEED`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SPEEDR { # [ doc = "Full-Speed mode" ] FULL_SPEED , # [ doc = "High-Speed mode" ] HIGH_SPEED , # [ doc = "Low-Speed mode" ] LOW_SPEED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SPEEDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SPEEDR :: FULL_SPEED => 0 , SPEEDR :: HIGH_SPEED => 0x01 , SPEEDR :: LOW_SPEED => 0x02 , SPEEDR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SPEEDR { match value { 0 => SPEEDR :: FULL_SPEED , 1 => SPEEDR :: HIGH_SPEED , 2 => SPEEDR :: LOW_SPEED , i => SPEEDR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `FULL_SPEED`" ] # [ inline ] pub fn is_full_speed ( & self ) -> bool { * self == SPEEDR :: FULL_SPEED } # [ doc = "Checks if the value of the field is `HIGH_SPEED`" ] # [ inline ] pub fn is_high_speed ( & self ) -> bool { * self == SPEEDR :: HIGH_SPEED } # [ doc = "Checks if the value of the field is `LOW_SPEED`" ] # [ inline ] pub fn is_low_speed ( & self ) -> bool { * self == SPEEDR :: LOW_SPEED } } # [ doc = r" Value of the field" ] pub struct CLKUSABLER { bits : bool , } impl CLKUSABLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - ID Transition Interrupt" ] # [ inline ] pub fn idti ( & self ) -> IDTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDTIR { bits } } # [ doc = "Bit 1 - VBus Transition Interrupt" ] # [ inline ] pub fn vbusti ( & self ) -> VBUSTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBUSTIR { bits } } # [ doc = "Bit 2 - SRP Interrupt" ] # [ inline ] pub fn srpi ( & self ) -> SRPIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SRPIR { bits } } # [ doc = "Bit 3 - VBus Error Interrupt" ] # [ inline ] pub fn vberri ( & self ) -> VBERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBERRIR { bits } } # [ doc = "Bit 4 - B-Connection Error Interrupt" ] # [ inline ] pub fn bcerri ( & self ) -> BCERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BCERRIR { bits } } # [ doc = "Bit 5 - Role Exchange Interrupt" ] # [ inline ] pub fn roleexi ( & self ) -> ROLEEXIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ROLEEXIR { bits } } # [ doc = "Bit 6 - HNP Error Interrupt" ] # [ inline ] pub fn hnperri ( & self ) -> HNPERRIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HNPERRIR { bits } } # [ doc = "Bit 7 - Suspend Time-Out Interrupt" ] # [ inline ] pub fn stoi ( & self ) -> STOIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STOIR { bits } } # [ doc = "Bit 9 - VBus Request" ] # [ inline ] pub fn vbusrq ( & self ) -> VBUSRQR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBUSRQR { bits } } # [ doc = "Bit 10 - UOTGID Pin State" ] # [ inline ] pub fn id ( & self ) -> IDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDR { bits } } # [ doc = "Bit 11 - VBus Level" ] # [ inline ] pub fn vbus ( & self ) -> VBUSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; VBUSR { bits } } # [ doc = "Bits 12:13 - Speed Status" ] # [ inline ] pub fn speed ( & self ) -> SPEEDR { SPEEDR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 14 - UTMI Clock Usable" ] # [ inline ] pub fn clkusable ( & self ) -> CLKUSABLER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKUSABLER { bits } } } } # [ doc = "General Status Clear Register" ] pub struct SCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "General Status Clear Register" ] pub mod scr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDTICW < 'a > { w : & 'a mut W , } impl < 'a > _IDTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBUSTICW < 'a > { w : & 'a mut W , } impl < 'a > _VBUSTICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SRPICW < 'a > { w : & 'a mut W , } impl < 'a > _SRPICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBERRICW < 'a > { w : & 'a mut W , } impl < 'a > _VBERRICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BCERRICW < 'a > { w : & 'a mut W , } impl < 'a > _BCERRICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ROLEEXICW < 'a > { w : & 'a mut W , } impl < 'a > _ROLEEXICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HNPERRICW < 'a > { w : & 'a mut W , } impl < 'a > _HNPERRICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STOICW < 'a > { w : & 'a mut W , } impl < 'a > _STOICW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBUSRQCW < 'a > { w : & 'a mut W , } impl < 'a > _VBUSRQCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - ID Transition Interrupt Clear" ] # [ inline ] pub fn idtic ( & mut self ) -> _IDTICW { _IDTICW { w : self } } # [ doc = "Bit 1 - VBus Transition Interrupt Clear" ] # [ inline ] pub fn vbustic ( & mut self ) -> _VBUSTICW { _VBUSTICW { w : self } } # [ doc = "Bit 2 - SRP Interrupt Clear" ] # [ inline ] pub fn srpic ( & mut self ) -> _SRPICW { _SRPICW { w : self } } # [ doc = "Bit 3 - VBus Error Interrupt Clear" ] # [ inline ] pub fn vberric ( & mut self ) -> _VBERRICW { _VBERRICW { w : self } } # [ doc = "Bit 4 - B-Connection Error Interrupt Clear" ] # [ inline ] pub fn bcerric ( & mut self ) -> _BCERRICW { _BCERRICW { w : self } } # [ doc = "Bit 5 - Role Exchange Interrupt Clear" ] # [ inline ] pub fn roleexic ( & mut self ) -> _ROLEEXICW { _ROLEEXICW { w : self } } # [ doc = "Bit 6 - HNP Error Interrupt Clear" ] # [ inline ] pub fn hnperric ( & mut self ) -> _HNPERRICW { _HNPERRICW { w : self } } # [ doc = "Bit 7 - Suspend Time-Out Interrupt Clear" ] # [ inline ] pub fn stoic ( & mut self ) -> _STOICW { _STOICW { w : self } } # [ doc = "Bit 9 - VBus Request Clear" ] # [ inline ] pub fn vbusrqc ( & mut self ) -> _VBUSRQCW { _VBUSRQCW { w : self } } } } # [ doc = "General Status Set Register" ] pub struct SFR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "General Status Set Register" ] pub mod sfr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SFR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _IDTISW < 'a > { w : & 'a mut W , } impl < 'a > _IDTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBUSTISW < 'a > { w : & 'a mut W , } impl < 'a > _VBUSTISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SRPISW < 'a > { w : & 'a mut W , } impl < 'a > _SRPISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBERRISW < 'a > { w : & 'a mut W , } impl < 'a > _VBERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BCERRISW < 'a > { w : & 'a mut W , } impl < 'a > _BCERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ROLEEXISW < 'a > { w : & 'a mut W , } impl < 'a > _ROLEEXISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HNPERRISW < 'a > { w : & 'a mut W , } impl < 'a > _HNPERRISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _STOISW < 'a > { w : & 'a mut W , } impl < 'a > _STOISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _VBUSRQSW < 'a > { w : & 'a mut W , } impl < 'a > _VBUSRQSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - ID Transition Interrupt Set" ] # [ inline ] pub fn idtis ( & mut self ) -> _IDTISW { _IDTISW { w : self } } # [ doc = "Bit 1 - VBus Transition Interrupt Set" ] # [ inline ] pub fn vbustis ( & mut self ) -> _VBUSTISW { _VBUSTISW { w : self } } # [ doc = "Bit 2 - SRP Interrupt Set" ] # [ inline ] pub fn srpis ( & mut self ) -> _SRPISW { _SRPISW { w : self } } # [ doc = "Bit 3 - VBus Error Interrupt Set" ] # [ inline ] pub fn vberris ( & mut self ) -> _VBERRISW { _VBERRISW { w : self } } # [ doc = "Bit 4 - B-Connection Error Interrupt Set" ] # [ inline ] pub fn bcerris ( & mut self ) -> _BCERRISW { _BCERRISW { w : self } } # [ doc = "Bit 5 - Role Exchange Interrupt Set" ] # [ inline ] pub fn roleexis ( & mut self ) -> _ROLEEXISW { _ROLEEXISW { w : self } } # [ doc = "Bit 6 - HNP Error Interrupt Set" ] # [ inline ] pub fn hnperris ( & mut self ) -> _HNPERRISW { _HNPERRISW { w : self } } # [ doc = "Bit 7 - Suspend Time-Out Interrupt Set" ] # [ inline ] pub fn stois ( & mut self ) -> _STOISW { _STOISW { w : self } } # [ doc = "Bit 9 - VBus Request Set" ] # [ inline ] pub fn vbusrqs ( & mut self ) -> _VBUSRQSW { _VBUSRQSW { w : self } } } } # [ doc = "General Finite State Machine Register" ] pub struct FSM { register : :: vcell :: VolatileCell < u32 > } # [ doc = "General Finite State Machine Register" ] pub mod fsm { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FSM { # [ doc = r" Reads the contents of the register" ] # [ inline ] pub fn read ( & self ) -> R { R { bits : self . register . get ( ) } } } # [ doc = "Possible values of the field `DRDSTATE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DRDSTATER { # [ doc = "This is the start state for A-devices (when the ID pin is 0)" ] A_IDLESTATE , # [ doc = "In this state, the A-device waits for the voltage on VBus to rise above the A-device VBus Valid threshold (4.4 V)." ] A_WAIT_VRISE , # [ doc = "In this state, the A-device waits for the B-device to signal a connection." ] A_WAIT_BCON , # [ doc = "In this state, the A-device that operates in Host mode is operational." ] A_HOST , # [ doc = "The A-device operating as a host is in the suspend mode." ] A_SUSPEND , # [ doc = "The A-device operates as a peripheral." ] A_PERIPHERAL , # [ doc = "In this state, the A-device waits for the voltage on VBus to drop below the A-device Session Valid threshold (1.4 V)." ] A_WAIT_VFALL , # [ doc = "In this state, the A-device waits for recovery of the over-current condition that caused it to enter this state." ] A_VBUS_ERR , # [ doc = "In this state, the A-device waits for the data USB line to discharge (100 us)." ] A_WAIT_DISCHARGE , # [ doc = "This is the start state for B-device (when the ID pin is 1)." ] B_IDLE , # [ doc = "In this state, the B-device acts as the peripheral." ] B_PERIPHERAL , # [ doc = "In this state, the B-device is in suspend mode and waits until 3 ms before initiating the HNP protocol if requested." ] B_WAIT_BEGIN_HNP , # [ doc = "In this state, the B-device waits for the data USB line to discharge (100 us) before becoming Host." ] B_WAIT_DISCHARGE , # [ doc = "In this state, the B-device waits for the A-device to signal a connect before becoming B-Host." ] B_WAIT_ACON , # [ doc = "In this state, the B-device acts as the Host." ] B_HOST , # [ doc = "In this state, the B-device attempts to start a session using the SRP protocol." ] B_SRP_INIT } impl DRDSTATER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DRDSTATER :: A_IDLESTATE => 0 , DRDSTATER :: A_WAIT_VRISE => 0x01 , DRDSTATER :: A_WAIT_BCON => 0x02 , DRDSTATER :: A_HOST => 0x03 , DRDSTATER :: A_SUSPEND => 0x04 , DRDSTATER :: A_PERIPHERAL => 0x05 , DRDSTATER :: A_WAIT_VFALL => 0x06 , DRDSTATER :: A_VBUS_ERR => 0x07 , DRDSTATER :: A_WAIT_DISCHARGE => 0x08 , DRDSTATER :: B_IDLE => 0x09 , DRDSTATER :: B_PERIPHERAL => 0x0a , DRDSTATER :: B_WAIT_BEGIN_HNP => 0x0b , DRDSTATER :: B_WAIT_DISCHARGE => 0x0c , DRDSTATER :: B_WAIT_ACON => 0x0d , DRDSTATER :: B_HOST => 0x0e , DRDSTATER :: B_SRP_INIT => 0x0f } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DRDSTATER { match value { 0 => DRDSTATER :: A_IDLESTATE , 1 => DRDSTATER :: A_WAIT_VRISE , 2 => DRDSTATER :: A_WAIT_BCON , 3 => DRDSTATER :: A_HOST , 4 => DRDSTATER :: A_SUSPEND , 5 => DRDSTATER :: A_PERIPHERAL , 6 => DRDSTATER :: A_WAIT_VFALL , 7 => DRDSTATER :: A_VBUS_ERR , 8 => DRDSTATER :: A_WAIT_DISCHARGE , 9 => DRDSTATER :: B_IDLE , 10 => DRDSTATER :: B_PERIPHERAL , 11 => DRDSTATER :: B_WAIT_BEGIN_HNP , 12 => DRDSTATER :: B_WAIT_DISCHARGE , 13 => DRDSTATER :: B_WAIT_ACON , 14 => DRDSTATER :: B_HOST , 15 => DRDSTATER :: B_SRP_INIT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `A_IDLESTATE`" ] # [ inline ] pub fn is_a_idlestate ( & self ) -> bool { * self == DRDSTATER :: A_IDLESTATE } # [ doc = "Checks if the value of the field is `A_WAIT_VRISE`" ] # [ inline ] pub fn is_a_wait_vrise ( & self ) -> bool { * self == DRDSTATER :: A_WAIT_VRISE } # [ doc = "Checks if the value of the field is `A_WAIT_BCON`" ] # [ inline ] pub fn is_a_wait_bcon ( & self ) -> bool { * self == DRDSTATER :: A_WAIT_BCON } # [ doc = "Checks if the value of the field is `A_HOST`" ] # [ inline ] pub fn is_a_host ( & self ) -> bool { * self == DRDSTATER :: A_HOST } # [ doc = "Checks if the value of the field is `A_SUSPEND`" ] # [ inline ] pub fn is_a_suspend ( & self ) -> bool { * self == DRDSTATER :: A_SUSPEND } # [ doc = "Checks if the value of the field is `A_PERIPHERAL`" ] # [ inline ] pub fn is_a_peripheral ( & self ) -> bool { * self == DRDSTATER :: A_PERIPHERAL } # [ doc = "Checks if the value of the field is `A_WAIT_VFALL`" ] # [ inline ] pub fn is_a_wait_vfall ( & self ) -> bool { * self == DRDSTATER :: A_WAIT_VFALL } # [ doc = "Checks if the value of the field is `A_VBUS_ERR`" ] # [ inline ] pub fn is_a_vbus_err ( & self ) -> bool { * self == DRDSTATER :: A_VBUS_ERR } # [ doc = "Checks if the value of the field is `A_WAIT_DISCHARGE`" ] # [ inline ] pub fn is_a_wait_discharge ( & self ) -> bool { * self == DRDSTATER :: A_WAIT_DISCHARGE } # [ doc = "Checks if the value of the field is `B_IDLE`" ] # [ inline ] pub fn is_b_idle ( & self ) -> bool { * self == DRDSTATER :: B_IDLE } # [ doc = "Checks if the value of the field is `B_PERIPHERAL`" ] # [ inline ] pub fn is_b_peripheral ( & self ) -> bool { * self == DRDSTATER :: B_PERIPHERAL } # [ doc = "Checks if the value of the field is `B_WAIT_BEGIN_HNP`" ] # [ inline ] pub fn is_b_wait_begin_hnp ( & self ) -> bool { * self == DRDSTATER :: B_WAIT_BEGIN_HNP } # [ doc = "Checks if the value of the field is `B_WAIT_DISCHARGE`" ] # [ inline ] pub fn is_b_wait_discharge ( & self ) -> bool { * self == DRDSTATER :: B_WAIT_DISCHARGE } # [ doc = "Checks if the value of the field is `B_WAIT_ACON`" ] # [ inline ] pub fn is_b_wait_acon ( & self ) -> bool { * self == DRDSTATER :: B_WAIT_ACON } # [ doc = "Checks if the value of the field is `B_HOST`" ] # [ inline ] pub fn is_b_host ( & self ) -> bool { * self == DRDSTATER :: B_HOST } # [ doc = "Checks if the value of the field is `B_SRP_INIT`" ] # [ inline ] pub fn is_b_srp_init ( & self ) -> bool { * self == DRDSTATER :: B_SRP_INIT } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Dual Role Device State" ] # [ inline ] pub fn drdstate ( & self ) -> DRDSTATER { DRDSTATER :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } } } # [ doc = "Ethernet MAC 10/100" ] pub struct EMAC { _marker : PhantomData < * const ( ) > } unsafe impl Send for EMAC { } impl EMAC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const emac :: RegisterBlock { 0x400b_0000 as * const _ } } impl Deref for EMAC { type Target = emac :: RegisterBlock ; fn deref ( & self ) -> & emac :: RegisterBlock { unsafe { & * EMAC :: ptr ( ) } } } # [ doc = "Ethernet MAC 10/100" ] pub mod emac { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Network Control Register" ] pub ncr : NCR , # [ doc = "0x04 - Network Configuration Register" ] pub ncfgr : NCFGR , # [ doc = "0x08 - Network Status Register" ] pub nsr : NSR , _reserved3 : [ u8 ; 8usize ] , # [ doc = "0x14 - Transmit Status Register" ] pub tsr : TSR , # [ doc = "0x18 - Receive Buffer Queue Pointer Register" ] pub rbqp : RBQP , # [ doc = "0x1c - Transmit Buffer Queue Pointer Register" ] pub tbqp : TBQP , # [ doc = "0x20 - Receive Status Register" ] pub rsr : RSR , # [ doc = "0x24 - Interrupt Status Register" ] pub isr : ISR , # [ doc = "0x28 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x2c - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x30 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x34 - Phy Maintenance Register" ] pub man : MAN , # [ doc = "0x38 - Pause Time Register" ] pub ptr : PTR , # [ doc = "0x3c - Pause Frames Received Register" ] pub pfr : PFR , # [ doc = "0x40 - Frames Transmitted Ok Register" ] pub fto : FTO , # [ doc = "0x44 - Single Collision Frames Register" ] pub scf : SCF , # [ doc = "0x48 - Multiple Collision Frames Register" ] pub mcf : MCF , # [ doc = "0x4c - Frames Received Ok Register" ] pub fro : FRO , # [ doc = "0x50 - Frame Check Sequence Errors Register" ] pub fcse : FCSE , # [ doc = "0x54 - Alignment Errors Register" ] pub ale : ALE , # [ doc = "0x58 - Deferred Transmission Frames Register" ] pub dtf : DTF , # [ doc = "0x5c - Late Collisions Register" ] pub lcol : LCOL , # [ doc = "0x60 - Excessive Collisions Register" ] pub ecol : ECOL , # [ doc = "0x64 - Transmit Underrun Errors Register" ] pub tund : TUND , # [ doc = "0x68 - Carrier Sense Errors Register" ] pub cse : CSE , # [ doc = "0x6c - Receive Resource Errors Register" ] pub rre : RRE , # [ doc = "0x70 - Receive Overrun Errors Register" ] pub rov : ROV , # [ doc = "0x74 - Receive Symbol Errors Register" ] pub rse : RSE , # [ doc = "0x78 - Excessive Length Errors Register" ] pub ele : ELE , # [ doc = "0x7c - Receive Jabbers Register" ] pub rja : RJA , # [ doc = "0x80 - Undersize Frames Register" ] pub usf : USF , # [ doc = "0x84 - SQE Test Errors Register" ] pub ste : STE , # [ doc = "0x88 - Received Length Field Mismatch Register" ] pub rle : RLE , _reserved33 : [ u8 ; 4usize ] , # [ doc = "0x90 - Hash Register Bottom \\[31:0\\] Register" ] pub hrb : HRB , # [ doc = "0x94 - Hash Register Top \\[63:32\\] Register" ] pub hrt : HRT , # [ doc = "0x98 - Specific Address 1 Bottom Register" ] pub sa1b : SA1B , # [ doc = "0x9c - Specific Address 1 Top Register" ] pub sa1t : SA1T , # [ doc = "0xa0 - Specific Address 2 Bottom Register" ] pub sa2b : SA2B , # [ doc = "0xa4 - Specific Address 2 Top Register" ] pub sa2t : SA2T , # [ doc = "0xa8 - Specific Address 3 Bottom Register" ] pub sa3b : SA3B , # [ doc = "0xac - Specific Address 3 Top Register" ] pub sa3t : SA3T , # [ doc = "0xb0 - Specific Address 4 Bottom Register" ] pub sa4b : SA4B , # [ doc = "0xb4 - Specific Address 4 Top Register" ] pub sa4t : SA4T , # [ doc = "0xb8 - Type ID Checking Register" ] pub tid : TID , _reserved44 : [ u8 ; 4usize ] , # [ doc = "0xc0 - User Input/Output Register" ] pub usrio : USRIO , } # [ doc = "Network Control Register" ] pub struct NCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Network Control Register" ] pub mod ncr { # [ 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 :: NCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 LBR { bits : bool , } impl LBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LLBR { bits : bool , } impl LLBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 MPER { bits : bool , } impl MPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CLRSTATR { bits : bool , } impl CLRSTATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct INCSTATR { bits : bool , } impl INCSTATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WESTATR { bits : bool , } impl WESTATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BPR { bits : bool , } impl BPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTARTR { bits : bool , } impl TSTARTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct THALTR { bits : bool , } impl THALTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _LBW < 'a > { w : & 'a mut W , } impl < 'a > _LBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LLBW < 'a > { w : & 'a mut W , } impl < 'a > _LLBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MPEW < 'a > { w : & 'a mut W , } impl < 'a > _MPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CLRSTATW < 'a > { w : & 'a mut W , } impl < 'a > _CLRSTATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _INCSTATW < 'a > { w : & 'a mut W , } impl < 'a > _INCSTATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WESTATW < 'a > { w : & 'a mut W , } impl < 'a > _WESTATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BPW < 'a > { w : & 'a mut W , } impl < 'a > _BPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTARTW < 'a > { w : & 'a mut W , } impl < 'a > _TSTARTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _THALTW < 'a > { w : & 'a mut W , } impl < 'a > _THALTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - LoopBack" ] # [ inline ] pub fn lb ( & self ) -> LBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LBR { bits } } # [ doc = "Bit 1 - Loopback local" ] # [ inline ] pub fn llb ( & self ) -> LLBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LLBR { bits } } # [ doc = "Bit 2 - Receive 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 - Transmit 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 - Management port enable" ] # [ inline ] pub fn mpe ( & self ) -> MPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MPER { bits } } # [ doc = "Bit 5 - Clear statistics registers" ] # [ inline ] pub fn clrstat ( & self ) -> CLRSTATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLRSTATR { bits } } # [ doc = "Bit 6 - Increment statistics registers" ] # [ inline ] pub fn incstat ( & self ) -> INCSTATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; INCSTATR { bits } } # [ doc = "Bit 7 - Write enable for statistics registers" ] # [ inline ] pub fn westat ( & self ) -> WESTATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WESTATR { bits } } # [ doc = "Bit 8 - Back pressure" ] # [ inline ] pub fn bp ( & self ) -> BPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BPR { bits } } # [ doc = "Bit 9 - Start transmission" ] # [ inline ] pub fn tstart ( & self ) -> TSTARTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTARTR { bits } } # [ doc = "Bit 10 - Transmit halt" ] # [ inline ] pub fn thalt ( & self ) -> THALTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; THALTR { 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 - LoopBack" ] # [ inline ] pub fn lb ( & mut self ) -> _LBW { _LBW { w : self } } # [ doc = "Bit 1 - Loopback local" ] # [ inline ] pub fn llb ( & mut self ) -> _LLBW { _LLBW { w : self } } # [ doc = "Bit 2 - Receive enable" ] # [ inline ] pub fn re ( & mut self ) -> _REW { _REW { w : self } } # [ doc = "Bit 3 - Transmit enable" ] # [ inline ] pub fn te ( & mut self ) -> _TEW { _TEW { w : self } } # [ doc = "Bit 4 - Management port enable" ] # [ inline ] pub fn mpe ( & mut self ) -> _MPEW { _MPEW { w : self } } # [ doc = "Bit 5 - Clear statistics registers" ] # [ inline ] pub fn clrstat ( & mut self ) -> _CLRSTATW { _CLRSTATW { w : self } } # [ doc = "Bit 6 - Increment statistics registers" ] # [ inline ] pub fn incstat ( & mut self ) -> _INCSTATW { _INCSTATW { w : self } } # [ doc = "Bit 7 - Write enable for statistics registers" ] # [ inline ] pub fn westat ( & mut self ) -> _WESTATW { _WESTATW { w : self } } # [ doc = "Bit 8 - Back pressure" ] # [ inline ] pub fn bp ( & mut self ) -> _BPW { _BPW { w : self } } # [ doc = "Bit 9 - Start transmission" ] # [ inline ] pub fn tstart ( & mut self ) -> _TSTARTW { _TSTARTW { w : self } } # [ doc = "Bit 10 - Transmit halt" ] # [ inline ] pub fn thalt ( & mut self ) -> _THALTW { _THALTW { w : self } } } } # [ doc = "Network Configuration Register" ] pub struct NCFGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Network Configuration Register" ] pub mod ncfgr { # [ 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 :: NCFGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SPDR { bits : bool , } impl SPDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FDR { bits : bool , } impl FDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct JFRAMER { bits : bool , } impl JFRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CAFR { bits : bool , } impl CAFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NBCR { bits : bool , } impl NBCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MTIR { bits : bool , } impl MTIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNIR { bits : bool , } impl UNIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BIGR { bits : bool , } impl BIGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `CLK`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CLKR { # [ doc = "MCK divided by 8 (MCK up to 20 MHz)." ] MCK_8 , # [ doc = "MCK divided by 16 (MCK up to 40 MHz)." ] MCK_16 , # [ doc = "MCK divided by 32 (MCK up to 80 MHz)." ] MCK_32 , # [ doc = "MCK divided by 64 (MCK up to 160 MHz)." ] MCK_64 } impl CLKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CLKR :: MCK_8 => 0 , CLKR :: MCK_16 => 0x01 , CLKR :: MCK_32 => 0x02 , CLKR :: MCK_64 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CLKR { match value { 0 => CLKR :: MCK_8 , 1 => CLKR :: MCK_16 , 2 => CLKR :: MCK_32 , 3 => CLKR :: MCK_64 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MCK_8`" ] # [ inline ] pub fn is_mck_8 ( & self ) -> bool { * self == CLKR :: MCK_8 } # [ doc = "Checks if the value of the field is `MCK_16`" ] # [ inline ] pub fn is_mck_16 ( & self ) -> bool { * self == CLKR :: MCK_16 } # [ doc = "Checks if the value of the field is `MCK_32`" ] # [ inline ] pub fn is_mck_32 ( & self ) -> bool { * self == CLKR :: MCK_32 } # [ doc = "Checks if the value of the field is `MCK_64`" ] # [ inline ] pub fn is_mck_64 ( & self ) -> bool { * self == CLKR :: MCK_64 } } # [ doc = r" Value of the field" ] pub struct RTYR { bits : bool , } impl RTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PAER { bits : bool , } impl PAER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `RBOF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RBOFR { # [ doc = "No offset from start of receive buffer." ] OFFSET_0 , # [ doc = "One-byte offset from start of receive buffer." ] OFFSET_1 , # [ doc = "Two-byte offset from start of receive buffer." ] OFFSET_2 , # [ doc = "Three-byte offset from start of receive buffer." ] OFFSET_3 } impl RBOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RBOFR :: OFFSET_0 => 0 , RBOFR :: OFFSET_1 => 0x01 , RBOFR :: OFFSET_2 => 0x02 , RBOFR :: OFFSET_3 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RBOFR { match value { 0 => RBOFR :: OFFSET_0 , 1 => RBOFR :: OFFSET_1 , 2 => RBOFR :: OFFSET_2 , 3 => RBOFR :: OFFSET_3 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `OFFSET_0`" ] # [ inline ] pub fn is_offset_0 ( & self ) -> bool { * self == RBOFR :: OFFSET_0 } # [ doc = "Checks if the value of the field is `OFFSET_1`" ] # [ inline ] pub fn is_offset_1 ( & self ) -> bool { * self == RBOFR :: OFFSET_1 } # [ doc = "Checks if the value of the field is `OFFSET_2`" ] # [ inline ] pub fn is_offset_2 ( & self ) -> bool { * self == RBOFR :: OFFSET_2 } # [ doc = "Checks if the value of the field is `OFFSET_3`" ] # [ inline ] pub fn is_offset_3 ( & self ) -> bool { * self == RBOFR :: OFFSET_3 } } # [ doc = r" Value of the field" ] pub struct RLCER { bits : bool , } impl RLCER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRFCSR { bits : bool , } impl DRFCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EFRHDR { bits : bool , } impl EFRHDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct IRXFCSR { bits : bool , } impl IRXFCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SPDW < 'a > { w : & 'a mut W , } impl < 'a > _SPDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FDW < 'a > { w : & 'a mut W , } impl < 'a > _FDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _JFRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _JFRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CAFW < 'a > { w : & 'a mut W , } impl < 'a > _CAFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NBCW < 'a > { w : & 'a mut W , } impl < 'a > _NBCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTIW < 'a > { w : & 'a mut W , } impl < 'a > _MTIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNIW < 'a > { w : & 'a mut W , } impl < 'a > _UNIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BIGW < 'a > { w : & 'a mut W , } impl < 'a > _BIGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `CLK`" ] pub enum CLKW { # [ doc = "MCK divided by 8 (MCK up to 20 MHz)." ] MCK_8 , # [ doc = "MCK divided by 16 (MCK up to 40 MHz)." ] MCK_16 , # [ doc = "MCK divided by 32 (MCK up to 80 MHz)." ] MCK_32 , # [ doc = "MCK divided by 64 (MCK up to 160 MHz)." ] MCK_64 } impl CLKW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CLKW :: MCK_8 => 0 , CLKW :: MCK_16 => 1 , CLKW :: MCK_32 => 2 , CLKW :: MCK_64 => 3 } } } # [ doc = r" Proxy" ] pub struct _CLKW < 'a > { w : & 'a mut W , } impl < 'a > _CLKW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CLKW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "MCK divided by 8 (MCK up to 20 MHz)." ] # [ inline ] pub fn mck_8 ( self ) -> & 'a mut W { self . variant ( CLKW :: MCK_8 ) } # [ doc = "MCK divided by 16 (MCK up to 40 MHz)." ] # [ inline ] pub fn mck_16 ( self ) -> & 'a mut W { self . variant ( CLKW :: MCK_16 ) } # [ doc = "MCK divided by 32 (MCK up to 80 MHz)." ] # [ inline ] pub fn mck_32 ( self ) -> & 'a mut W { self . variant ( CLKW :: MCK_32 ) } # [ doc = "MCK divided by 64 (MCK up to 160 MHz)." ] # [ inline ] pub fn mck_64 ( self ) -> & 'a mut W { self . variant ( CLKW :: MCK_64 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _RTYW < 'a > { w : & 'a mut W , } impl < 'a > _RTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAEW < 'a > { w : & 'a mut W , } impl < 'a > _PAEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `RBOF`" ] pub enum RBOFW { # [ doc = "No offset from start of receive buffer." ] OFFSET_0 , # [ doc = "One-byte offset from start of receive buffer." ] OFFSET_1 , # [ doc = "Two-byte offset from start of receive buffer." ] OFFSET_2 , # [ doc = "Three-byte offset from start of receive buffer." ] OFFSET_3 } impl RBOFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RBOFW :: OFFSET_0 => 0 , RBOFW :: OFFSET_1 => 1 , RBOFW :: OFFSET_2 => 2 , RBOFW :: OFFSET_3 => 3 } } } # [ doc = r" Proxy" ] pub struct _RBOFW < 'a > { w : & 'a mut W , } impl < 'a > _RBOFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RBOFW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "No offset from start of receive buffer." ] # [ inline ] pub fn offset_0 ( self ) -> & 'a mut W { self . variant ( RBOFW :: OFFSET_0 ) } # [ doc = "One-byte offset from start of receive buffer." ] # [ inline ] pub fn offset_1 ( self ) -> & 'a mut W { self . variant ( RBOFW :: OFFSET_1 ) } # [ doc = "Two-byte offset from start of receive buffer." ] # [ inline ] pub fn offset_2 ( self ) -> & 'a mut W { self . variant ( RBOFW :: OFFSET_2 ) } # [ doc = "Three-byte offset from start of receive buffer." ] # [ inline ] pub fn offset_3 ( self ) -> & 'a mut W { self . variant ( RBOFW :: OFFSET_3 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _RLCEW < 'a > { w : & 'a mut W , } impl < 'a > _RLCEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRFCSW < 'a > { w : & 'a mut W , } impl < 'a > _DRFCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EFRHDW < 'a > { w : & 'a mut W , } impl < 'a > _EFRHDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _IRXFCSW < 'a > { w : & 'a mut W , } impl < 'a > _IRXFCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Speed" ] # [ inline ] pub fn spd ( & self ) -> SPDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SPDR { bits } } # [ doc = "Bit 1 - Full Duplex" ] # [ inline ] pub fn fd ( & self ) -> FDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FDR { bits } } # [ doc = "Bit 3 - Jumbo Frames" ] # [ inline ] pub fn jframe ( & self ) -> JFRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; JFRAMER { bits } } # [ doc = "Bit 4 - Copy All Frames" ] # [ inline ] pub fn caf ( & self ) -> CAFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CAFR { bits } } # [ doc = "Bit 5 - No Broadcast" ] # [ inline ] pub fn nbc ( & self ) -> NBCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NBCR { bits } } # [ doc = "Bit 6 - Multicast Hash Enable" ] # [ inline ] pub fn mti ( & self ) -> MTIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTIR { bits } } # [ doc = "Bit 7 - Unicast Hash Enable" ] # [ inline ] pub fn uni ( & self ) -> UNIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNIR { bits } } # [ doc = "Bit 8 - Receive 1536 bytes frames" ] # [ inline ] pub fn big ( & self ) -> BIGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BIGR { bits } } # [ doc = "Bits 10:11 - MDC clock divider" ] # [ inline ] pub fn clk ( & self ) -> CLKR { CLKR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Retry test" ] # [ inline ] pub fn rty ( & self ) -> RTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTYR { bits } } # [ doc = "Bit 13 - Pause Enable" ] # [ inline ] pub fn pae ( & self ) -> PAER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PAER { bits } } # [ doc = "Bits 14:15 - Receive Buffer Offset" ] # [ inline ] pub fn rbof ( & self ) -> RBOFR { RBOFR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - Receive Length field Checking Enable" ] # [ inline ] pub fn rlce ( & self ) -> RLCER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RLCER { bits } } # [ doc = "Bit 17 - Discard Receive FCS" ] # [ inline ] pub fn drfcs ( & self ) -> DRFCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRFCSR { bits } } # [ doc = "Bit 18" ] # [ inline ] pub fn efrhd ( & self ) -> EFRHDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EFRHDR { bits } } # [ doc = "Bit 19 - Ignore RX FCS" ] # [ inline ] pub fn irxfcs ( & self ) -> IRXFCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IRXFCSR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0800 } } # [ 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 - Speed" ] # [ inline ] pub fn spd ( & mut self ) -> _SPDW { _SPDW { w : self } } # [ doc = "Bit 1 - Full Duplex" ] # [ inline ] pub fn fd ( & mut self ) -> _FDW { _FDW { w : self } } # [ doc = "Bit 3 - Jumbo Frames" ] # [ inline ] pub fn jframe ( & mut self ) -> _JFRAMEW { _JFRAMEW { w : self } } # [ doc = "Bit 4 - Copy All Frames" ] # [ inline ] pub fn caf ( & mut self ) -> _CAFW { _CAFW { w : self } } # [ doc = "Bit 5 - No Broadcast" ] # [ inline ] pub fn nbc ( & mut self ) -> _NBCW { _NBCW { w : self } } # [ doc = "Bit 6 - Multicast Hash Enable" ] # [ inline ] pub fn mti ( & mut self ) -> _MTIW { _MTIW { w : self } } # [ doc = "Bit 7 - Unicast Hash Enable" ] # [ inline ] pub fn uni ( & mut self ) -> _UNIW { _UNIW { w : self } } # [ doc = "Bit 8 - Receive 1536 bytes frames" ] # [ inline ] pub fn big ( & mut self ) -> _BIGW { _BIGW { w : self } } # [ doc = "Bits 10:11 - MDC clock divider" ] # [ inline ] pub fn clk ( & mut self ) -> _CLKW { _CLKW { w : self } } # [ doc = "Bit 12 - Retry test" ] # [ inline ] pub fn rty ( & mut self ) -> _RTYW { _RTYW { w : self } } # [ doc = "Bit 13 - Pause Enable" ] # [ inline ] pub fn pae ( & mut self ) -> _PAEW { _PAEW { w : self } } # [ doc = "Bits 14:15 - Receive Buffer Offset" ] # [ inline ] pub fn rbof ( & mut self ) -> _RBOFW { _RBOFW { w : self } } # [ doc = "Bit 16 - Receive Length field Checking Enable" ] # [ inline ] pub fn rlce ( & mut self ) -> _RLCEW { _RLCEW { w : self } } # [ doc = "Bit 17 - Discard Receive FCS" ] # [ inline ] pub fn drfcs ( & mut self ) -> _DRFCSW { _DRFCSW { w : self } } # [ doc = "Bit 18" ] # [ inline ] pub fn efrhd ( & mut self ) -> _EFRHDW { _EFRHDW { w : self } } # [ doc = "Bit 19 - Ignore RX FCS" ] # [ inline ] pub fn irxfcs ( & mut self ) -> _IRXFCSW { _IRXFCSW { w : self } } } } # [ doc = "Network Status Register" ] pub struct NSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Network Status Register" ] pub mod nsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: NSR { # [ 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 MDIOR { bits : bool , } impl MDIOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ( ) } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 1" ] # [ inline ] pub fn mdio ( & self ) -> MDIOR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MDIOR { bits } } # [ doc = "Bit 2" ] # [ inline ] pub fn idle ( & self ) -> IDLER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IDLER { bits } } } } # [ doc = "Transmit Status Register" ] pub struct TSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Status Register" ] pub mod tsr { # [ 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 :: TSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 UBRR { bits : bool , } impl UBRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct COLR { bits : bool , } impl COLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RLESR { bits : bool , } impl RLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TGOR { bits : bool , } impl TGOR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BEXR { bits : bool , } impl BEXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct COMPR { bits : bool , } impl COMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDR { bits : bool , } impl UNDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _UBRW < 'a > { w : & 'a mut W , } impl < 'a > _UBRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _COLW < 'a > { w : & 'a mut W , } impl < 'a > _COLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RLESW < 'a > { w : & 'a mut W , } impl < 'a > _RLESW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TGOW < 'a > { w : & 'a mut W , } impl < 'a > _TGOW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BEXW < 'a > { w : & 'a mut W , } impl < 'a > _BEXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _COMPW < 'a > { w : & 'a mut W , } impl < 'a > _COMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDW < 'a > { w : & 'a mut W , } impl < 'a > _UNDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Used Bit Read" ] # [ inline ] pub fn ubr ( & self ) -> UBRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UBRR { bits } } # [ doc = "Bit 1 - Collision Occurred" ] # [ inline ] pub fn col ( & self ) -> COLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COLR { bits } } # [ doc = "Bit 2 - Retry Limit exceeded" ] # [ inline ] pub fn rles ( & self ) -> RLESR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RLESR { bits } } # [ doc = "Bit 3 - Transmit Go" ] # [ inline ] pub fn tgo ( & self ) -> TGOR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TGOR { bits } } # [ doc = "Bit 4 - Buffers exhausted mid frame" ] # [ inline ] pub fn bex ( & self ) -> BEXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BEXR { bits } } # [ doc = "Bit 5 - Transmit Complete" ] # [ inline ] pub fn comp ( & self ) -> COMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COMPR { bits } } # [ doc = "Bit 6 - Transmit Underrun" ] # [ inline ] pub fn und ( & self ) -> UNDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDR { 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 - Used Bit Read" ] # [ inline ] pub fn ubr ( & mut self ) -> _UBRW { _UBRW { w : self } } # [ doc = "Bit 1 - Collision Occurred" ] # [ inline ] pub fn col ( & mut self ) -> _COLW { _COLW { w : self } } # [ doc = "Bit 2 - Retry Limit exceeded" ] # [ inline ] pub fn rles ( & mut self ) -> _RLESW { _RLESW { w : self } } # [ doc = "Bit 3 - Transmit Go" ] # [ inline ] pub fn tgo ( & mut self ) -> _TGOW { _TGOW { w : self } } # [ doc = "Bit 4 - Buffers exhausted mid frame" ] # [ inline ] pub fn bex ( & mut self ) -> _BEXW { _BEXW { w : self } } # [ doc = "Bit 5 - Transmit Complete" ] # [ inline ] pub fn comp ( & mut self ) -> _COMPW { _COMPW { w : self } } # [ doc = "Bit 6 - Transmit Underrun" ] # [ inline ] pub fn und ( & mut self ) -> _UNDW { _UNDW { w : self } } } } # [ doc = "Receive Buffer Queue Pointer Register" ] pub struct RBQP { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Buffer Queue Pointer Register" ] pub mod rbqp { # [ 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 :: RBQP { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Receive buffer queue pointer address" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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 2:31 - Receive buffer queue pointer address" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Transmit Buffer Queue Pointer Register" ] pub struct TBQP { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Buffer Queue Pointer Register" ] pub mod tbqp { # [ 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 :: TBQP { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Transmit buffer queue pointer address" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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 2:31 - Transmit buffer queue pointer address" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Receive Status Register" ] pub struct RSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Status Register" ] pub mod rsr { # [ 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 :: RSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BNAR { bits : bool , } impl BNAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECR { bits : bool , } impl RECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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" Proxy" ] pub struct _BNAW < 'a > { w : & 'a mut W , } impl < 'a > _BNAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RECW < 'a > { w : & 'a mut W , } impl < 'a > _RECW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 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 0 - Buffer Not Available" ] # [ inline ] pub fn bna ( & self ) -> BNAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BNAR { bits } } # [ doc = "Bit 1 - Frame Received" ] # [ inline ] pub fn rec ( & self ) -> RECR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECR { bits } } # [ doc = "Bit 2 - Receive Overrun" ] # [ inline ] pub fn ovr ( & self ) -> OVRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRR { 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 - Buffer Not Available" ] # [ inline ] pub fn bna ( & mut self ) -> _BNAW { _BNAW { w : self } } # [ doc = "Bit 1 - Frame Received" ] # [ inline ] pub fn rec ( & mut self ) -> _RECW { _RECW { w : self } } # [ doc = "Bit 2 - Receive Overrun" ] # [ inline ] pub fn ovr ( & mut self ) -> _OVRW { _OVRW { w : self } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt 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 < F > ( & 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 < F > ( & 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 MFDR { bits : bool , } impl MFDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCOMPR { bits : bool , } impl RCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXUBRR { bits : bool , } impl RXUBRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXUBRR { bits : bool , } impl TXUBRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TUNDR { bits : bool , } impl TUNDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RLEXR { bits : bool , } impl RLEXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXERRR { bits : bool , } impl TXERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TCOMPR { bits : bool , } impl TCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ROVRR { bits : bool , } impl ROVRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HRESPR { bits : bool , } impl HRESPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PFRER { bits : bool , } impl PFRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PTZR { bits : bool , } impl PTZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MFDW < 'a > { w : & 'a mut W , } impl < 'a > _MFDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _RCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXUBRW < 'a > { w : & 'a mut W , } impl < 'a > _RXUBRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXUBRW < 'a > { w : & 'a mut W , } impl < 'a > _TXUBRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TUNDW < 'a > { w : & 'a mut W , } impl < 'a > _TUNDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RLEXW < 'a > { w : & 'a mut W , } impl < 'a > _RLEXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXERRW < 'a > { w : & 'a mut W , } impl < 'a > _TXERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _TCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ROVRW < 'a > { w : & 'a mut W , } impl < 'a > _ROVRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HRESPW < 'a > { w : & 'a mut W , } impl < 'a > _HRESPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFREW < 'a > { w : & 'a mut W , } impl < 'a > _PFREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PTZW < 'a > { w : & 'a mut W , } impl < 'a > _PTZW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Management Frame Done" ] # [ inline ] pub fn mfd ( & self ) -> MFDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MFDR { bits } } # [ doc = "Bit 1 - Receive Complete" ] # [ inline ] pub fn rcomp ( & self ) -> RCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCOMPR { bits } } # [ doc = "Bit 2 - Receive Used Bit Read" ] # [ inline ] pub fn rxubr ( & self ) -> RXUBRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXUBRR { bits } } # [ doc = "Bit 3 - Transmit Used Bit Read" ] # [ inline ] pub fn txubr ( & self ) -> TXUBRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXUBRR { bits } } # [ doc = "Bit 4 - Ethernet Transmit Buffer Underrun" ] # [ inline ] pub fn tund ( & self ) -> TUNDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TUNDR { bits } } # [ doc = "Bit 5 - Retry Limit Exceeded" ] # [ inline ] pub fn rlex ( & self ) -> RLEXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RLEXR { bits } } # [ doc = "Bit 6 - Transmit Error" ] # [ inline ] pub fn txerr ( & self ) -> TXERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXERRR { bits } } # [ doc = "Bit 7 - Transmit Complete" ] # [ inline ] pub fn tcomp ( & self ) -> TCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TCOMPR { bits } } # [ doc = "Bit 10 - Receive Overrun" ] # [ inline ] pub fn rovr ( & self ) -> ROVRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ROVRR { bits } } # [ doc = "Bit 11 - Hresp not OK" ] # [ inline ] pub fn hresp ( & self ) -> HRESPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HRESPR { bits } } # [ doc = "Bit 12 - Pause Frame Received" ] # [ inline ] pub fn pfre ( & self ) -> PFRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PFRER { bits } } # [ doc = "Bit 13 - Pause Time Zero" ] # [ inline ] pub fn ptz ( & self ) -> PTZR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PTZR { 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 - Management Frame Done" ] # [ inline ] pub fn mfd ( & mut self ) -> _MFDW { _MFDW { w : self } } # [ doc = "Bit 1 - Receive Complete" ] # [ inline ] pub fn rcomp ( & mut self ) -> _RCOMPW { _RCOMPW { w : self } } # [ doc = "Bit 2 - Receive Used Bit Read" ] # [ inline ] pub fn rxubr ( & mut self ) -> _RXUBRW { _RXUBRW { w : self } } # [ doc = "Bit 3 - Transmit Used Bit Read" ] # [ inline ] pub fn txubr ( & mut self ) -> _TXUBRW { _TXUBRW { w : self } } # [ doc = "Bit 4 - Ethernet Transmit Buffer Underrun" ] # [ inline ] pub fn tund ( & mut self ) -> _TUNDW { _TUNDW { w : self } } # [ doc = "Bit 5 - Retry Limit Exceeded" ] # [ inline ] pub fn rlex ( & mut self ) -> _RLEXW { _RLEXW { w : self } } # [ doc = "Bit 6 - Transmit Error" ] # [ inline ] pub fn txerr ( & mut self ) -> _TXERRW { _TXERRW { w : self } } # [ doc = "Bit 7 - Transmit Complete" ] # [ inline ] pub fn tcomp ( & mut self ) -> _TCOMPW { _TCOMPW { w : self } } # [ doc = "Bit 10 - Receive Overrun" ] # [ inline ] pub fn rovr ( & mut self ) -> _ROVRW { _ROVRW { w : self } } # [ doc = "Bit 11 - Hresp not OK" ] # [ inline ] pub fn hresp ( & mut self ) -> _HRESPW { _HRESPW { w : self } } # [ doc = "Bit 12 - Pause Frame Received" ] # [ inline ] pub fn pfre ( & mut self ) -> _PFREW { _PFREW { w : self } } # [ doc = "Bit 13 - Pause Time Zero" ] # [ inline ] pub fn ptz ( & mut self ) -> _PTZW { _PTZW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MFDW < 'a > { w : & 'a mut W , } impl < 'a > _MFDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _RCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXUBRW < 'a > { w : & 'a mut W , } impl < 'a > _RXUBRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXUBRW < 'a > { w : & 'a mut W , } impl < 'a > _TXUBRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TUNDW < 'a > { w : & 'a mut W , } impl < 'a > _TUNDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RLEW < 'a > { w : & 'a mut W , } impl < 'a > _RLEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXERRW < 'a > { w : & 'a mut W , } impl < 'a > _TXERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _TCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ROVRW < 'a > { w : & 'a mut W , } impl < 'a > _ROVRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HRESPW < 'a > { w : & 'a mut W , } impl < 'a > _HRESPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFRW < 'a > { w : & 'a mut W , } impl < 'a > _PFRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PTZW < 'a > { w : & 'a mut W , } impl < 'a > _PTZW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Management Frame sent" ] # [ inline ] pub fn mfd ( & mut self ) -> _MFDW { _MFDW { w : self } } # [ doc = "Bit 1 - Receive Complete" ] # [ inline ] pub fn rcomp ( & mut self ) -> _RCOMPW { _RCOMPW { w : self } } # [ doc = "Bit 2 - Receive Used Bit Read" ] # [ inline ] pub fn rxubr ( & mut self ) -> _RXUBRW { _RXUBRW { w : self } } # [ doc = "Bit 3 - Transmit Used Bit Read" ] # [ inline ] pub fn txubr ( & mut self ) -> _TXUBRW { _TXUBRW { w : self } } # [ doc = "Bit 4 - Ethernet Transmit Buffer Underrun" ] # [ inline ] pub fn tund ( & mut self ) -> _TUNDW { _TUNDW { w : self } } # [ doc = "Bit 5 - Retry Limit Exceeded" ] # [ inline ] pub fn rle ( & mut self ) -> _RLEW { _RLEW { w : self } } # [ doc = "Bit 6" ] # [ inline ] pub fn txerr ( & mut self ) -> _TXERRW { _TXERRW { w : self } } # [ doc = "Bit 7 - Transmit Complete" ] # [ inline ] pub fn tcomp ( & mut self ) -> _TCOMPW { _TCOMPW { w : self } } # [ doc = "Bit 10 - Receive Overrun" ] # [ inline ] pub fn rovr ( & mut self ) -> _ROVRW { _ROVRW { w : self } } # [ doc = "Bit 11 - Hresp not OK" ] # [ inline ] pub fn hresp ( & mut self ) -> _HRESPW { _HRESPW { w : self } } # [ doc = "Bit 12 - Pause Frame Received" ] # [ inline ] pub fn pfr ( & mut self ) -> _PFRW { _PFRW { w : self } } # [ doc = "Bit 13 - Pause Time Zero" ] # [ inline ] pub fn ptz ( & mut self ) -> _PTZW { _PTZW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MFDW < 'a > { w : & 'a mut W , } impl < 'a > _MFDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _RCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXUBRW < 'a > { w : & 'a mut W , } impl < 'a > _RXUBRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXUBRW < 'a > { w : & 'a mut W , } impl < 'a > _TXUBRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TUNDW < 'a > { w : & 'a mut W , } impl < 'a > _TUNDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RLEW < 'a > { w : & 'a mut W , } impl < 'a > _RLEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXERRW < 'a > { w : & 'a mut W , } impl < 'a > _TXERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TCOMPW < 'a > { w : & 'a mut W , } impl < 'a > _TCOMPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ROVRW < 'a > { w : & 'a mut W , } impl < 'a > _ROVRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HRESPW < 'a > { w : & 'a mut W , } impl < 'a > _HRESPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PFRW < 'a > { w : & 'a mut W , } impl < 'a > _PFRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PTZW < 'a > { w : & 'a mut W , } impl < 'a > _PTZW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Management Frame sent" ] # [ inline ] pub fn mfd ( & mut self ) -> _MFDW { _MFDW { w : self } } # [ doc = "Bit 1 - Receive Complete" ] # [ inline ] pub fn rcomp ( & mut self ) -> _RCOMPW { _RCOMPW { w : self } } # [ doc = "Bit 2 - Receive Used Bit Read" ] # [ inline ] pub fn rxubr ( & mut self ) -> _RXUBRW { _RXUBRW { w : self } } # [ doc = "Bit 3 - Transmit Used Bit Read" ] # [ inline ] pub fn txubr ( & mut self ) -> _TXUBRW { _TXUBRW { w : self } } # [ doc = "Bit 4 - Ethernet Transmit Buffer Underrun" ] # [ inline ] pub fn tund ( & mut self ) -> _TUNDW { _TUNDW { w : self } } # [ doc = "Bit 5 - Retry Limit Exceeded" ] # [ inline ] pub fn rle ( & mut self ) -> _RLEW { _RLEW { w : self } } # [ doc = "Bit 6" ] # [ inline ] pub fn txerr ( & mut self ) -> _TXERRW { _TXERRW { w : self } } # [ doc = "Bit 7 - Transmit Complete" ] # [ inline ] pub fn tcomp ( & mut self ) -> _TCOMPW { _TCOMPW { w : self } } # [ doc = "Bit 10 - Receive Overrun" ] # [ inline ] pub fn rovr ( & mut self ) -> _ROVRW { _ROVRW { w : self } } # [ doc = "Bit 11 - Hresp not OK" ] # [ inline ] pub fn hresp ( & mut self ) -> _HRESPW { _HRESPW { w : self } } # [ doc = "Bit 12 - Pause Frame Received" ] # [ inline ] pub fn pfr ( & mut self ) -> _PFRW { _PFRW { w : self } } # [ doc = "Bit 13 - Pause Time Zero" ] # [ inline ] pub fn ptz ( & mut self ) -> _PTZW { _PTZW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 MFDR { bits : bool , } impl MFDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCOMPR { bits : bool , } impl RCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXUBRR { bits : bool , } impl RXUBRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXUBRR { bits : bool , } impl TXUBRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TUNDR { bits : bool , } impl TUNDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RLER { bits : bool , } impl RLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXERRR { bits : bool , } impl TXERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TCOMPR { bits : bool , } impl TCOMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ROVRR { bits : bool , } impl ROVRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HRESPR { bits : bool , } impl HRESPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PFRR { bits : bool , } impl PFRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PTZR { bits : bool , } impl PTZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Management Frame sent" ] # [ inline ] pub fn mfd ( & self ) -> MFDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MFDR { bits } } # [ doc = "Bit 1 - Receive Complete" ] # [ inline ] pub fn rcomp ( & self ) -> RCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCOMPR { bits } } # [ doc = "Bit 2 - Receive Used Bit Read" ] # [ inline ] pub fn rxubr ( & self ) -> RXUBRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXUBRR { bits } } # [ doc = "Bit 3 - Transmit Used Bit Read" ] # [ inline ] pub fn txubr ( & self ) -> TXUBRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXUBRR { bits } } # [ doc = "Bit 4 - Ethernet Transmit Buffer Underrun" ] # [ inline ] pub fn tund ( & self ) -> TUNDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TUNDR { bits } } # [ doc = "Bit 5 - Retry Limit Exceeded" ] # [ inline ] pub fn rle ( & self ) -> RLER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RLER { bits } } # [ doc = "Bit 6" ] # [ inline ] pub fn txerr ( & self ) -> TXERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXERRR { bits } } # [ doc = "Bit 7 - Transmit Complete" ] # [ inline ] pub fn tcomp ( & self ) -> TCOMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TCOMPR { bits } } # [ doc = "Bit 10 - Receive Overrun" ] # [ inline ] pub fn rovr ( & self ) -> ROVRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ROVRR { bits } } # [ doc = "Bit 11 - Hresp not OK" ] # [ inline ] pub fn hresp ( & self ) -> HRESPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HRESPR { bits } } # [ doc = "Bit 12 - Pause Frame Received" ] # [ inline ] pub fn pfr ( & self ) -> PFRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PFRR { bits } } # [ doc = "Bit 13 - Pause Time Zero" ] # [ inline ] pub fn ptz ( & self ) -> PTZR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PTZR { bits } } } } # [ doc = "Phy Maintenance Register" ] pub struct MAN { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Phy Maintenance Register" ] pub mod man { # [ 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 :: MAN { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DATAR { bits : u16 , } impl DATAR { # [ 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 CODER { bits : u8 , } impl CODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct REGAR { bits : u8 , } impl REGAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PHYAR { bits : u8 , } impl PHYAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RWR { bits : u8 , } impl RWR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct SOFR { bits : u8 , } impl SOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _DATAW < 'a > { w : & 'a mut W , } impl < 'a > _DATAW < '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 } } # [ doc = r" Proxy" ] pub struct _CODEW < 'a > { w : & 'a mut W , } impl < 'a > _CODEW < '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 _REGAW < 'a > { w : & 'a mut W , } impl < 'a > _REGAW < '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 = 18 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _PHYAW < 'a > { w : & 'a mut W , } impl < 'a > _PHYAW < '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 = 23 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _RWW < 'a > { w : & 'a mut W , } impl < 'a > _RWW < '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 _SOFW < 'a > { w : & 'a mut W , } impl < 'a > _SOFW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15" ] # [ 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 = "Bits 16:17" ] # [ inline ] pub fn code ( & self ) -> CODER { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CODER { bits } } # [ doc = "Bits 18:22 - Register Address" ] # [ inline ] pub fn rega ( & self ) -> REGAR { let bits = { const MASK : u8 = 0x1f ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; REGAR { bits } } # [ doc = "Bits 23:27 - PHY Address" ] # [ inline ] pub fn phya ( & self ) -> PHYAR { let bits = { const MASK : u8 = 0x1f ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PHYAR { bits } } # [ doc = "Bits 28:29 - Read-write" ] # [ inline ] pub fn rw ( & self ) -> RWR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RWR { bits } } # [ doc = "Bits 30:31 - Start of frame" ] # [ inline ] pub fn sof ( & self ) -> SOFR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SOFR { 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" ] # [ inline ] pub fn data ( & mut self ) -> _DATAW { _DATAW { w : self } } # [ doc = "Bits 16:17" ] # [ inline ] pub fn code ( & mut self ) -> _CODEW { _CODEW { w : self } } # [ doc = "Bits 18:22 - Register Address" ] # [ inline ] pub fn rega ( & mut self ) -> _REGAW { _REGAW { w : self } } # [ doc = "Bits 23:27 - PHY Address" ] # [ inline ] pub fn phya ( & mut self ) -> _PHYAW { _PHYAW { w : self } } # [ doc = "Bits 28:29 - Read-write" ] # [ inline ] pub fn rw ( & mut self ) -> _RWW { _RWW { w : self } } # [ doc = "Bits 30:31 - Start of frame" ] # [ inline ] pub fn sof ( & mut self ) -> _SOFW { _SOFW { w : self } } } } # [ doc = "Pause Time Register" ] pub struct PTR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pause Time Register" ] pub mod ptr { # [ 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 :: PTR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 PTIMER { bits : u16 , } impl PTIMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _PTIMEW < 'a > { w : & 'a mut W , } impl < 'a > _PTIMEW < '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 - Pause Time" ] # [ inline ] pub fn ptime ( & self ) -> PTIMER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; PTIMER { 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 - Pause Time" ] # [ inline ] pub fn ptime ( & mut self ) -> _PTIMEW { _PTIMEW { w : self } } } } # [ doc = "Pause Frames Received Register" ] pub struct PFR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pause Frames Received Register" ] pub mod pfr { # [ 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 :: PFR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FROKR { bits : u16 , } impl FROKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _FROKW < 'a > { w : & 'a mut W , } impl < 'a > _FROKW < '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 - Pause Frames received OK" ] # [ inline ] pub fn frok ( & self ) -> FROKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; FROKR { 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 - Pause Frames received OK" ] # [ inline ] pub fn frok ( & mut self ) -> _FROKW { _FROKW { w : self } } } } # [ doc = "Frames Transmitted Ok Register" ] pub struct FTO { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Frames Transmitted Ok Register" ] pub mod fto { # [ 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 :: FTO { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FTOKR { bits : u32 , } impl FTOKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _FTOKW < 'a > { w : & 'a mut W , } impl < 'a > _FTOKW < '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 0:23 - Frames Transmitted OK" ] # [ inline ] pub fn ftok ( & self ) -> FTOKR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; FTOKR { 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:23 - Frames Transmitted OK" ] # [ inline ] pub fn ftok ( & mut self ) -> _FTOKW { _FTOKW { w : self } } } } # [ doc = "Single Collision Frames Register" ] pub struct SCF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Single Collision Frames Register" ] pub mod scf { # [ 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 :: SCF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SCFR { bits : u16 , } impl SCFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _SCFW < 'a > { w : & 'a mut W , } impl < 'a > _SCFW < '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 - Single Collision Frames" ] # [ inline ] pub fn scf ( & self ) -> SCFR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; SCFR { 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 - Single Collision Frames" ] # [ inline ] pub fn scf ( & mut self ) -> _SCFW { _SCFW { w : self } } } } # [ doc = "Multiple Collision Frames Register" ] pub struct MCF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multiple Collision Frames Register" ] pub mod mcf { # [ 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 :: MCF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MCFR { bits : u16 , } impl MCFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _MCFW < 'a > { w : & 'a mut W , } impl < 'a > _MCFW < '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 - Multicollision Frames" ] # [ inline ] pub fn mcf ( & self ) -> MCFR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MCFR { 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 - Multicollision Frames" ] # [ inline ] pub fn mcf ( & mut self ) -> _MCFW { _MCFW { w : self } } } } # [ doc = "Frames Received Ok Register" ] pub struct FRO { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Frames Received Ok Register" ] pub mod fro { # [ 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 :: FRO { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FROKR { bits : u32 , } impl FROKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _FROKW < 'a > { w : & 'a mut W , } impl < 'a > _FROKW < '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 0:23 - Frames Received OK" ] # [ inline ] pub fn frok ( & self ) -> FROKR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; FROKR { 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:23 - Frames Received OK" ] # [ inline ] pub fn frok ( & mut self ) -> _FROKW { _FROKW { w : self } } } } # [ doc = "Frame Check Sequence Errors Register" ] pub struct FCSE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Frame Check Sequence Errors Register" ] pub mod fcse { # [ 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 :: FCSE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FCSER { bits : u8 , } impl FCSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _FCSEW < 'a > { w : & 'a mut W , } impl < 'a > _FCSEW < '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 - Frame Check Sequence Errors" ] # [ inline ] pub fn fcse ( & self ) -> FCSER { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FCSER { 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 - Frame Check Sequence Errors" ] # [ inline ] pub fn fcse ( & mut self ) -> _FCSEW { _FCSEW { w : self } } } } # [ doc = "Alignment Errors Register" ] pub struct ALE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Alignment Errors Register" ] pub mod ale { # [ 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 :: ALE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ALER { bits : u8 , } impl ALER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _ALEW < 'a > { w : & 'a mut W , } impl < 'a > _ALEW < '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 - Alignment Errors" ] # [ inline ] pub fn ale ( & self ) -> ALER { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; ALER { 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 - Alignment Errors" ] # [ inline ] pub fn ale ( & mut self ) -> _ALEW { _ALEW { w : self } } } } # [ doc = "Deferred Transmission Frames Register" ] pub struct DTF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Deferred Transmission Frames Register" ] pub mod dtf { # [ 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 :: DTF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DTFR { bits : u16 , } impl DTFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DTFW < 'a > { w : & 'a mut W , } impl < 'a > _DTFW < '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 - Deferred Transmission Frames" ] # [ inline ] pub fn dtf ( & self ) -> DTFR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DTFR { 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 - Deferred Transmission Frames" ] # [ inline ] pub fn dtf ( & mut self ) -> _DTFW { _DTFW { w : self } } } } # [ doc = "Late Collisions Register" ] pub struct LCOL { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Late Collisions Register" ] pub mod lcol { # [ 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 :: LCOL { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 LCOLR { bits : u8 , } impl LCOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _LCOLW < 'a > { w : & 'a mut W , } impl < 'a > _LCOLW < '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 - Late Collisions" ] # [ inline ] pub fn lcol ( & self ) -> LCOLR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; LCOLR { 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 - Late Collisions" ] # [ inline ] pub fn lcol ( & mut self ) -> _LCOLW { _LCOLW { w : self } } } } # [ doc = "Excessive Collisions Register" ] pub struct ECOL { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Excessive Collisions Register" ] pub mod ecol { # [ 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 :: ECOL { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 EXCOLR { bits : u8 , } impl EXCOLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _EXCOLW < 'a > { w : & 'a mut W , } impl < 'a > _EXCOLW < '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 - Excessive Collisions" ] # [ inline ] pub fn excol ( & self ) -> EXCOLR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; EXCOLR { 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 - Excessive Collisions" ] # [ inline ] pub fn excol ( & mut self ) -> _EXCOLW { _EXCOLW { w : self } } } } # [ doc = "Transmit Underrun Errors Register" ] pub struct TUND { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Underrun Errors Register" ] pub mod tund { # [ 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 :: TUND { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TUNDR { bits : u8 , } impl TUNDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _TUNDW < 'a > { w : & 'a mut W , } impl < 'a > _TUNDW < '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 - Transmit Underruns" ] # [ inline ] pub fn tund ( & self ) -> TUNDR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TUNDR { 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 - Transmit Underruns" ] # [ inline ] pub fn tund ( & mut self ) -> _TUNDW { _TUNDW { w : self } } } } # [ doc = "Carrier Sense Errors Register" ] pub struct CSE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Carrier Sense Errors Register" ] pub mod cse { # [ 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 :: CSE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CSER { bits : u8 , } impl CSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CSEW < 'a > { w : & 'a mut W , } impl < 'a > _CSEW < '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 - Carrier Sense Errors" ] # [ inline ] pub fn cse ( & self ) -> CSER { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CSER { 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 - Carrier Sense Errors" ] # [ inline ] pub fn cse ( & mut self ) -> _CSEW { _CSEW { w : self } } } } # [ doc = "Receive Resource Errors Register" ] pub struct RRE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Resource Errors Register" ] pub mod rre { # [ 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 :: RRE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RRER { bits : u16 , } impl RRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RREW < 'a > { w : & 'a mut W , } impl < 'a > _RREW < '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 - Receive Resource Errors" ] # [ inline ] pub fn rre ( & self ) -> RRER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RRER { 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 - Receive Resource Errors" ] # [ inline ] pub fn rre ( & mut self ) -> _RREW { _RREW { w : self } } } } # [ doc = "Receive Overrun Errors Register" ] pub struct ROV { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Overrun Errors Register" ] pub mod rov { # [ 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 :: ROV { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ROVRR { bits : u8 , } impl ROVRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _ROVRW < 'a > { w : & 'a mut W , } impl < 'a > _ROVRW < '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 - Receive Overrun" ] # [ inline ] pub fn rovr ( & self ) -> ROVRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; ROVRR { 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 - Receive Overrun" ] # [ inline ] pub fn rovr ( & mut self ) -> _ROVRW { _ROVRW { w : self } } } } # [ doc = "Receive Symbol Errors Register" ] pub struct RSE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Symbol Errors Register" ] pub mod rse { # [ 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 :: RSE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RSER { bits : u8 , } impl RSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _RSEW < 'a > { w : & 'a mut W , } impl < 'a > _RSEW < '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 - Receive Symbol Errors" ] # [ inline ] pub fn rse ( & self ) -> RSER { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RSER { 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 - Receive Symbol Errors" ] # [ inline ] pub fn rse ( & mut self ) -> _RSEW { _RSEW { w : self } } } } # [ doc = "Excessive Length Errors Register" ] pub struct ELE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Excessive Length Errors Register" ] pub mod ele { # [ 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 :: ELE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 EXLR { bits : u8 , } impl EXLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _EXLW < 'a > { w : & 'a mut W , } impl < 'a > _EXLW < '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 - Excessive Length Errors" ] # [ inline ] pub fn exl ( & self ) -> EXLR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; EXLR { 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 - Excessive Length Errors" ] # [ inline ] pub fn exl ( & mut self ) -> _EXLW { _EXLW { w : self } } } } # [ doc = "Receive Jabbers Register" ] pub struct RJA { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Jabbers Register" ] pub mod rja { # [ 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 :: RJA { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RJBR { bits : u8 , } impl RJBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _RJBW < 'a > { w : & 'a mut W , } impl < 'a > _RJBW < '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 - Receive Jabbers" ] # [ inline ] pub fn rjb ( & self ) -> RJBR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RJBR { 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 - Receive Jabbers" ] # [ inline ] pub fn rjb ( & mut self ) -> _RJBW { _RJBW { w : self } } } } # [ doc = "Undersize Frames Register" ] pub struct USF { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Undersize Frames Register" ] pub mod usf { # [ 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 :: USF { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 USFR { bits : u8 , } impl USFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _USFW < 'a > { w : & 'a mut W , } impl < 'a > _USFW < '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 - Undersize frames" ] # [ inline ] pub fn usf ( & self ) -> USFR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USFR { 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 - Undersize frames" ] # [ inline ] pub fn usf ( & mut self ) -> _USFW { _USFW { w : self } } } } # [ doc = "SQE Test Errors Register" ] pub struct STE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SQE Test Errors Register" ] pub mod ste { # [ 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 :: STE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SQERR { bits : u8 , } impl SQERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _SQERW < 'a > { w : & 'a mut W , } impl < 'a > _SQERW < '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 - SQE test errors" ] # [ inline ] pub fn sqer ( & self ) -> SQERR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SQERR { 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 - SQE test errors" ] # [ inline ] pub fn sqer ( & mut self ) -> _SQERW { _SQERW { w : self } } } } # [ doc = "Received Length Field Mismatch Register" ] pub struct RLE { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Received Length Field Mismatch Register" ] pub mod rle { # [ 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 :: RLE { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RLFMR { bits : u8 , } impl RLFMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _RLFMW < 'a > { w : & 'a mut W , } impl < 'a > _RLFMW < '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 - Receive Length Field Mismatch" ] # [ inline ] pub fn rlfm ( & self ) -> RLFMR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RLFMR { 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 - Receive Length Field Mismatch" ] # [ inline ] pub fn rlfm ( & mut self ) -> _RLFMW { _RLFMW { w : self } } } } # [ doc = "Hash Register Bottom \\[31:0\\] Register" ] pub struct HRB { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Hash Register Bottom \\[31:0\\] Register" ] pub mod hrb { # [ 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 :: HRB { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Hash Register Top \\[63:32\\] Register" ] pub struct HRT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Hash Register Top \\[63:32\\] Register" ] pub mod hrt { # [ 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 :: HRT { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 1 Bottom Register" ] pub struct SA1B { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 1 Bottom Register" ] pub mod sa1b { # [ 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 :: SA1B { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 1 Top Register" ] pub struct SA1T { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 1 Top Register" ] pub mod sa1t { # [ 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 :: SA1T { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u16 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 2 Bottom Register" ] pub struct SA2B { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 2 Bottom Register" ] pub mod sa2b { # [ 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 :: SA2B { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 2 Top Register" ] pub struct SA2T { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 2 Top Register" ] pub mod sa2t { # [ 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 :: SA2T { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u16 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 3 Bottom Register" ] pub struct SA3B { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 3 Bottom Register" ] pub mod sa3b { # [ 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 :: SA3B { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 3 Top Register" ] pub struct SA3T { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 3 Top Register" ] pub mod sa3t { # [ 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 :: SA3T { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u16 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 4 Bottom Register" ] pub struct SA4B { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 4 Bottom Register" ] pub mod sa4b { # [ 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 :: SA4B { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u32 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Specific Address 4 Top Register" ] pub struct SA4T { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Specific Address 4 Top Register" ] pub mod sa4t { # [ 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 :: SA4T { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDRR { bits : u16 , } impl ADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDRW < 'a > { w : & 'a mut W , } impl < 'a > _ADDRW < '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" ] # [ inline ] pub fn addr ( & self ) -> ADDRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; ADDRR { 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" ] # [ inline ] pub fn addr ( & mut self ) -> _ADDRW { _ADDRW { w : self } } } } # [ doc = "Type ID Checking Register" ] pub struct TID { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Type ID Checking Register" ] pub mod tid { # [ 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 :: TID { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TIDR { bits : u16 , } impl TIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TIDW < 'a > { w : & 'a mut W , } impl < 'a > _TIDW < '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 - Type ID checking" ] # [ inline ] pub fn tid ( & self ) -> TIDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TIDR { 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 - Type ID checking" ] # [ inline ] pub fn tid ( & mut self ) -> _TIDW { _TIDW { w : self } } } } # [ doc = "User Input/Output Register" ] pub struct USRIO { register : :: vcell :: VolatileCell < u32 > } # [ doc = "User Input/Output Register" ] pub mod usrio { # [ 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 :: USRIO { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RMIIR { bits : bool , } impl RMIIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ 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" Proxy" ] pub struct _RMIIW < 'a > { w : & 'a mut W , } impl < 'a > _RMIIW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 1 ; 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 - Reduce MII" ] # [ inline ] pub fn rmii ( & self ) -> RMIIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RMIIR { bits } } # [ doc = "Bit 1 - Clock Enable" ] # [ inline ] pub fn clken ( & self ) -> CLKENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CLKENR { 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 - Reduce MII" ] # [ inline ] pub fn rmii ( & mut self ) -> _RMIIW { _RMIIW { w : self } } # [ doc = "Bit 1 - Clock Enable" ] # [ inline ] pub fn clken ( & mut self ) -> _CLKENW { _CLKENW { w : self } } } } } # [ doc = "Controller Area Network 0" ] pub struct CAN0 { _marker : PhantomData < * const ( ) > } unsafe impl Send for CAN0 { } impl CAN0 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const can0 :: RegisterBlock { 0x400b_4000 as * const _ } } impl Deref for CAN0 { type Target = can0 :: RegisterBlock ; fn deref ( & self ) -> & can0 :: RegisterBlock { unsafe { & * CAN0 :: ptr ( ) } } } # [ doc = "Controller Area Network 0" ] pub mod can0 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Mode Register" ] pub mr : MR , # [ doc = "0x04 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x08 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x0c - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x10 - Status Register" ] pub sr : SR , # [ doc = "0x14 - Baudrate Register" ] pub br : BR , # [ doc = "0x18 - Timer Register" ] pub tim : TIM , # [ doc = "0x1c - Timestamp Register" ] pub timestp : TIMESTP , # [ doc = "0x20 - Error Counter Register" ] pub ecr : ECR , # [ doc = "0x24 - Transfer Command Register" ] pub tcr : TCR , # [ doc = "0x28 - Abort Command Register" ] pub acr : ACR , _reserved11 : [ u8 ; 184usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , _reserved13 : [ u8 ; 276usize ] , # [ doc = "0x200 - Mailbox Mode Register (MB = 0)" ] pub mmr0 : MMR0 , # [ doc = "0x204 - Mailbox Acceptance Mask Register (MB = 0)" ] pub mam0 : MAM0 , # [ doc = "0x208 - Mailbox ID Register (MB = 0)" ] pub mid0 : MID0 , # [ doc = "0x20c - Mailbox Family ID Register (MB = 0)" ] pub mfid0 : MFID0 , # [ doc = "0x210 - Mailbox Status Register (MB = 0)" ] pub msr0 : MSR0 , # [ doc = "0x214 - Mailbox Data Low Register (MB = 0)" ] pub mdl0 : MDL0 , # [ doc = "0x218 - Mailbox Data High Register (MB = 0)" ] pub mdh0 : MDH0 , # [ doc = "0x21c - Mailbox Control Register (MB = 0)" ] pub mcr0 : MCR0 , # [ doc = "0x220 - Mailbox Mode Register (MB = 1)" ] pub mmr1 : MMR1 , # [ doc = "0x224 - Mailbox Acceptance Mask Register (MB = 1)" ] pub mam1 : MAM1 , # [ doc = "0x228 - Mailbox ID Register (MB = 1)" ] pub mid1 : MID1 , # [ doc = "0x22c - Mailbox Family ID Register (MB = 1)" ] pub mfid1 : MFID1 , # [ doc = "0x230 - Mailbox Status Register (MB = 1)" ] pub msr1 : MSR1 , # [ doc = "0x234 - Mailbox Data Low Register (MB = 1)" ] pub mdl1 : MDL1 , # [ doc = "0x238 - Mailbox Data High Register (MB = 1)" ] pub mdh1 : MDH1 , # [ doc = "0x23c - Mailbox Control Register (MB = 1)" ] pub mcr1 : MCR1 , # [ doc = "0x240 - Mailbox Mode Register (MB = 2)" ] pub mmr2 : MMR2 , # [ doc = "0x244 - Mailbox Acceptance Mask Register (MB = 2)" ] pub mam2 : MAM2 , # [ doc = "0x248 - Mailbox ID Register (MB = 2)" ] pub mid2 : MID2 , # [ doc = "0x24c - Mailbox Family ID Register (MB = 2)" ] pub mfid2 : MFID2 , # [ doc = "0x250 - Mailbox Status Register (MB = 2)" ] pub msr2 : MSR2 , # [ doc = "0x254 - Mailbox Data Low Register (MB = 2)" ] pub mdl2 : MDL2 , # [ doc = "0x258 - Mailbox Data High Register (MB = 2)" ] pub mdh2 : MDH2 , # [ doc = "0x25c - Mailbox Control Register (MB = 2)" ] pub mcr2 : MCR2 , # [ doc = "0x260 - Mailbox Mode Register (MB = 3)" ] pub mmr3 : MMR3 , # [ doc = "0x264 - Mailbox Acceptance Mask Register (MB = 3)" ] pub mam3 : MAM3 , # [ doc = "0x268 - Mailbox ID Register (MB = 3)" ] pub mid3 : MID3 , # [ doc = "0x26c - Mailbox Family ID Register (MB = 3)" ] pub mfid3 : MFID3 , # [ doc = "0x270 - Mailbox Status Register (MB = 3)" ] pub msr3 : MSR3 , # [ doc = "0x274 - Mailbox Data Low Register (MB = 3)" ] pub mdl3 : MDL3 , # [ doc = "0x278 - Mailbox Data High Register (MB = 3)" ] pub mdh3 : MDH3 , # [ doc = "0x27c - Mailbox Control Register (MB = 3)" ] pub mcr3 : MCR3 , # [ doc = "0x280 - Mailbox Mode Register (MB = 4)" ] pub mmr4 : MMR4 , # [ doc = "0x284 - Mailbox Acceptance Mask Register (MB = 4)" ] pub mam4 : MAM4 , # [ doc = "0x288 - Mailbox ID Register (MB = 4)" ] pub mid4 : MID4 , # [ doc = "0x28c - Mailbox Family ID Register (MB = 4)" ] pub mfid4 : MFID4 , # [ doc = "0x290 - Mailbox Status Register (MB = 4)" ] pub msr4 : MSR4 , # [ doc = "0x294 - Mailbox Data Low Register (MB = 4)" ] pub mdl4 : MDL4 , # [ doc = "0x298 - Mailbox Data High Register (MB = 4)" ] pub mdh4 : MDH4 , # [ doc = "0x29c - Mailbox Control Register (MB = 4)" ] pub mcr4 : MCR4 , # [ doc = "0x2a0 - Mailbox Mode Register (MB = 5)" ] pub mmr5 : MMR5 , # [ doc = "0x2a4 - Mailbox Acceptance Mask Register (MB = 5)" ] pub mam5 : MAM5 , # [ doc = "0x2a8 - Mailbox ID Register (MB = 5)" ] pub mid5 : MID5 , # [ doc = "0x2ac - Mailbox Family ID Register (MB = 5)" ] pub mfid5 : MFID5 , # [ doc = "0x2b0 - Mailbox Status Register (MB = 5)" ] pub msr5 : MSR5 , # [ doc = "0x2b4 - Mailbox Data Low Register (MB = 5)" ] pub mdl5 : MDL5 , # [ doc = "0x2b8 - Mailbox Data High Register (MB = 5)" ] pub mdh5 : MDH5 , # [ doc = "0x2bc - Mailbox Control Register (MB = 5)" ] pub mcr5 : MCR5 , # [ doc = "0x2c0 - Mailbox Mode Register (MB = 6)" ] pub mmr6 : MMR6 , # [ doc = "0x2c4 - Mailbox Acceptance Mask Register (MB = 6)" ] pub mam6 : MAM6 , # [ doc = "0x2c8 - Mailbox ID Register (MB = 6)" ] pub mid6 : MID6 , # [ doc = "0x2cc - Mailbox Family ID Register (MB = 6)" ] pub mfid6 : MFID6 , # [ doc = "0x2d0 - Mailbox Status Register (MB = 6)" ] pub msr6 : MSR6 , # [ doc = "0x2d4 - Mailbox Data Low Register (MB = 6)" ] pub mdl6 : MDL6 , # [ doc = "0x2d8 - Mailbox Data High Register (MB = 6)" ] pub mdh6 : MDH6 , # [ doc = "0x2dc - Mailbox Control Register (MB = 6)" ] pub mcr6 : MCR6 , # [ doc = "0x2e0 - Mailbox Mode Register (MB = 7)" ] pub mmr7 : MMR7 , # [ doc = "0x2e4 - Mailbox Acceptance Mask Register (MB = 7)" ] pub mam7 : MAM7 , # [ doc = "0x2e8 - Mailbox ID Register (MB = 7)" ] pub mid7 : MID7 , # [ doc = "0x2ec - Mailbox Family ID Register (MB = 7)" ] pub mfid7 : MFID7 , # [ doc = "0x2f0 - Mailbox Status Register (MB = 7)" ] pub msr7 : MSR7 , # [ doc = "0x2f4 - Mailbox Data Low Register (MB = 7)" ] pub mdl7 : MDL7 , # [ doc = "0x2f8 - Mailbox Data High Register (MB = 7)" ] pub mdh7 : MDH7 , # [ doc = "0x2fc - Mailbox Control Register (MB = 7)" ] pub mcr7 : MCR7 , } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CANENR { bits : bool , } impl CANENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LPMR { bits : bool , } impl LPMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ABMR { bits : bool , } impl ABMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVLR { bits : bool , } impl OVLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TEOFR { bits : bool , } impl TEOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TTMR { bits : bool , } impl TTMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TIMFRZR { bits : bool , } impl TIMFRZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRPTR { bits : bool , } impl DRPTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `RXSYNC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RXSYNCR { # [ doc = "Rx Signal with Double Synchro Stages (2 Positive Edges)" ] DOUBLE_PP , # [ doc = "Rx Signal with Double Synchro Stages (One Positive Edge and One Negative Edge)" ] DOUBLE_PN , # [ doc = "Rx Signal with Single Synchro Stage (Positive Edge)" ] SINGLE_P , # [ doc = "Rx Signal with No Synchro Stage" ] NONE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl RXSYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RXSYNCR :: DOUBLE_PP => 0 , RXSYNCR :: DOUBLE_PN => 0x01 , RXSYNCR :: SINGLE_P => 0x02 , RXSYNCR :: NONE => 0x03 , RXSYNCR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RXSYNCR { match value { 0 => RXSYNCR :: DOUBLE_PP , 1 => RXSYNCR :: DOUBLE_PN , 2 => RXSYNCR :: SINGLE_P , 3 => RXSYNCR :: NONE , i => RXSYNCR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DOUBLE_PP`" ] # [ inline ] pub fn is_double_pp ( & self ) -> bool { * self == RXSYNCR :: DOUBLE_PP } # [ doc = "Checks if the value of the field is `DOUBLE_PN`" ] # [ inline ] pub fn is_double_pn ( & self ) -> bool { * self == RXSYNCR :: DOUBLE_PN } # [ doc = "Checks if the value of the field is `SINGLE_P`" ] # [ inline ] pub fn is_single_p ( & self ) -> bool { * self == RXSYNCR :: SINGLE_P } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == RXSYNCR :: NONE } } # [ doc = r" Proxy" ] pub struct _CANENW < 'a > { w : & 'a mut W , } impl < 'a > _CANENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LPMW < 'a > { w : & 'a mut W , } impl < 'a > _LPMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ABMW < 'a > { w : & 'a mut W , } impl < 'a > _ABMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVLW < 'a > { w : & 'a mut W , } impl < 'a > _OVLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TEOFW < 'a > { w : & 'a mut W , } impl < 'a > _TEOFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TTMW < 'a > { w : & 'a mut W , } impl < 'a > _TTMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMFRZW < 'a > { w : & 'a mut W , } impl < 'a > _TIMFRZW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRPTW < 'a > { w : & 'a mut W , } impl < 'a > _DRPTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `RXSYNC`" ] pub enum RXSYNCW { # [ doc = "Rx Signal with Double Synchro Stages (2 Positive Edges)" ] DOUBLE_PP , # [ doc = "Rx Signal with Double Synchro Stages (One Positive Edge and One Negative Edge)" ] DOUBLE_PN , # [ doc = "Rx Signal with Single Synchro Stage (Positive Edge)" ] SINGLE_P , # [ doc = "Rx Signal with No Synchro Stage" ] NONE } impl RXSYNCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RXSYNCW :: DOUBLE_PP => 0 , RXSYNCW :: DOUBLE_PN => 1 , RXSYNCW :: SINGLE_P => 2 , RXSYNCW :: NONE => 3 } } } # [ doc = r" Proxy" ] pub struct _RXSYNCW < 'a > { w : & 'a mut W , } impl < 'a > _RXSYNCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RXSYNCW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Rx Signal with Double Synchro Stages (2 Positive Edges)" ] # [ inline ] pub fn double_pp ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: DOUBLE_PP ) } # [ doc = "Rx Signal with Double Synchro Stages (One Positive Edge and One Negative Edge)" ] # [ inline ] pub fn double_pn ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: DOUBLE_PN ) } # [ doc = "Rx Signal with Single Synchro Stage (Positive Edge)" ] # [ inline ] pub fn single_p ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: SINGLE_P ) } # [ doc = "Rx Signal with No Synchro Stage" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: NONE ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - CAN Controller Enable" ] # [ inline ] pub fn canen ( & self ) -> CANENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CANENR { bits } } # [ doc = "Bit 1 - Disable/Enable Low Power Mode" ] # [ inline ] pub fn lpm ( & self ) -> LPMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LPMR { bits } } # [ doc = "Bit 2 - Disable/Enable Autobaud/Listen mode" ] # [ inline ] pub fn abm ( & self ) -> ABMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABMR { bits } } # [ doc = "Bit 3 - Disable/Enable Overload Frame" ] # [ inline ] pub fn ovl ( & self ) -> OVLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVLR { bits } } # [ doc = "Bit 4 - Timestamp messages at each end of Frame" ] # [ inline ] pub fn teof ( & self ) -> TEOFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TEOFR { bits } } # [ doc = "Bit 5 - Disable/Enable Time Triggered Mode" ] # [ inline ] pub fn ttm ( & self ) -> TTMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TTMR { bits } } # [ doc = "Bit 6 - Enable Timer Freeze" ] # [ inline ] pub fn timfrz ( & self ) -> TIMFRZR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMFRZR { bits } } # [ doc = "Bit 7 - Disable Repeat" ] # [ inline ] pub fn drpt ( & self ) -> DRPTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRPTR { bits } } # [ doc = "Bits 24:26 - Reception Synchronization Stage (not readable)" ] # [ inline ] pub fn rxsync ( & self ) -> RXSYNCR { RXSYNCR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - CAN Controller Enable" ] # [ inline ] pub fn canen ( & mut self ) -> _CANENW { _CANENW { w : self } } # [ doc = "Bit 1 - Disable/Enable Low Power Mode" ] # [ inline ] pub fn lpm ( & mut self ) -> _LPMW { _LPMW { w : self } } # [ doc = "Bit 2 - Disable/Enable Autobaud/Listen mode" ] # [ inline ] pub fn abm ( & mut self ) -> _ABMW { _ABMW { w : self } } # [ doc = "Bit 3 - Disable/Enable Overload Frame" ] # [ inline ] pub fn ovl ( & mut self ) -> _OVLW { _OVLW { w : self } } # [ doc = "Bit 4 - Timestamp messages at each end of Frame" ] # [ inline ] pub fn teof ( & mut self ) -> _TEOFW { _TEOFW { w : self } } # [ doc = "Bit 5 - Disable/Enable Time Triggered Mode" ] # [ inline ] pub fn ttm ( & mut self ) -> _TTMW { _TTMW { w : self } } # [ doc = "Bit 6 - Enable Timer Freeze" ] # [ inline ] pub fn timfrz ( & mut self ) -> _TIMFRZW { _TIMFRZW { w : self } } # [ doc = "Bit 7 - Disable Repeat" ] # [ inline ] pub fn drpt ( & mut self ) -> _DRPTW { _DRPTW { w : self } } # [ doc = "Bits 24:26 - Reception Synchronization Stage (not readable)" ] # [ inline ] pub fn rxsync ( & mut self ) -> _RXSYNCW { _RXSYNCW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRAW < 'a > { w : & 'a mut W , } impl < 'a > _ERRAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WARNW < 'a > { w : & 'a mut W , } impl < 'a > _WARNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRPW < 'a > { w : & 'a mut W , } impl < 'a > _ERRPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BOFFW < 'a > { w : & 'a mut W , } impl < 'a > _BOFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLEEPW < 'a > { w : & 'a mut W , } impl < 'a > _SLEEPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TOVFW < 'a > { w : & 'a mut W , } impl < 'a > _TOVFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTPW < 'a > { w : & 'a mut W , } impl < 'a > _TSTPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CERRW < 'a > { w : & 'a mut W , } impl < 'a > _CERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SERRW < 'a > { w : & 'a mut W , } impl < 'a > _SERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AERRW < 'a > { w : & 'a mut W , } impl < 'a > _AERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FERRW < 'a > { w : & 'a mut W , } impl < 'a > _FERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BERRW < 'a > { w : & 'a mut W , } impl < 'a > _BERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Mailbox 0 Interrupt Enable" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Mailbox 1 Interrupt Enable" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Mailbox 2 Interrupt Enable" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Mailbox 3 Interrupt Enable" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Mailbox 4 Interrupt Enable" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Mailbox 5 Interrupt Enable" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Mailbox 6 Interrupt Enable" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Mailbox 7 Interrupt Enable" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } # [ doc = "Bit 16 - Error Active Mode Interrupt Enable" ] # [ inline ] pub fn erra ( & mut self ) -> _ERRAW { _ERRAW { w : self } } # [ doc = "Bit 17 - Warning Limit Interrupt Enable" ] # [ inline ] pub fn warn ( & mut self ) -> _WARNW { _WARNW { w : self } } # [ doc = "Bit 18 - Error Passive Mode Interrupt Enable" ] # [ inline ] pub fn errp ( & mut self ) -> _ERRPW { _ERRPW { w : self } } # [ doc = "Bit 19 - Bus Off Mode Interrupt Enable" ] # [ inline ] pub fn boff ( & mut self ) -> _BOFFW { _BOFFW { w : self } } # [ doc = "Bit 20 - Sleep Interrupt Enable" ] # [ inline ] pub fn sleep ( & mut self ) -> _SLEEPW { _SLEEPW { w : self } } # [ doc = "Bit 21 - Wakeup Interrupt Enable" ] # [ inline ] pub fn wakeup ( & mut self ) -> _WAKEUPW { _WAKEUPW { w : self } } # [ doc = "Bit 22 - Timer Overflow Interrupt Enable" ] # [ inline ] pub fn tovf ( & mut self ) -> _TOVFW { _TOVFW { w : self } } # [ doc = "Bit 23 - TimeStamp Interrupt Enable" ] # [ inline ] pub fn tstp ( & mut self ) -> _TSTPW { _TSTPW { w : self } } # [ doc = "Bit 24 - CRC Error Interrupt Enable" ] # [ inline ] pub fn cerr ( & mut self ) -> _CERRW { _CERRW { w : self } } # [ doc = "Bit 25 - Stuffing Error Interrupt Enable" ] # [ inline ] pub fn serr ( & mut self ) -> _SERRW { _SERRW { w : self } } # [ doc = "Bit 26 - Acknowledgment Error Interrupt Enable" ] # [ inline ] pub fn aerr ( & mut self ) -> _AERRW { _AERRW { w : self } } # [ doc = "Bit 27 - Form Error Interrupt Enable" ] # [ inline ] pub fn ferr ( & mut self ) -> _FERRW { _FERRW { w : self } } # [ doc = "Bit 28 - Bit Error Interrupt Enable" ] # [ inline ] pub fn berr ( & mut self ) -> _BERRW { _BERRW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRAW < 'a > { w : & 'a mut W , } impl < 'a > _ERRAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WARNW < 'a > { w : & 'a mut W , } impl < 'a > _WARNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRPW < 'a > { w : & 'a mut W , } impl < 'a > _ERRPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BOFFW < 'a > { w : & 'a mut W , } impl < 'a > _BOFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLEEPW < 'a > { w : & 'a mut W , } impl < 'a > _SLEEPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TOVFW < 'a > { w : & 'a mut W , } impl < 'a > _TOVFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTPW < 'a > { w : & 'a mut W , } impl < 'a > _TSTPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CERRW < 'a > { w : & 'a mut W , } impl < 'a > _CERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SERRW < 'a > { w : & 'a mut W , } impl < 'a > _SERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AERRW < 'a > { w : & 'a mut W , } impl < 'a > _AERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FERRW < 'a > { w : & 'a mut W , } impl < 'a > _FERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BERRW < 'a > { w : & 'a mut W , } impl < 'a > _BERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Mailbox 0 Interrupt Disable" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Mailbox 1 Interrupt Disable" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Mailbox 2 Interrupt Disable" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Mailbox 3 Interrupt Disable" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Mailbox 4 Interrupt Disable" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Mailbox 5 Interrupt Disable" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Mailbox 6 Interrupt Disable" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Mailbox 7 Interrupt Disable" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } # [ doc = "Bit 16 - Error Active Mode Interrupt Disable" ] # [ inline ] pub fn erra ( & mut self ) -> _ERRAW { _ERRAW { w : self } } # [ doc = "Bit 17 - Warning Limit Interrupt Disable" ] # [ inline ] pub fn warn ( & mut self ) -> _WARNW { _WARNW { w : self } } # [ doc = "Bit 18 - Error Passive Mode Interrupt Disable" ] # [ inline ] pub fn errp ( & mut self ) -> _ERRPW { _ERRPW { w : self } } # [ doc = "Bit 19 - Bus Off Mode Interrupt Disable" ] # [ inline ] pub fn boff ( & mut self ) -> _BOFFW { _BOFFW { w : self } } # [ doc = "Bit 20 - Sleep Interrupt Disable" ] # [ inline ] pub fn sleep ( & mut self ) -> _SLEEPW { _SLEEPW { w : self } } # [ doc = "Bit 21 - Wakeup Interrupt Disable" ] # [ inline ] pub fn wakeup ( & mut self ) -> _WAKEUPW { _WAKEUPW { w : self } } # [ doc = "Bit 22 - Timer Overflow Interrupt" ] # [ inline ] pub fn tovf ( & mut self ) -> _TOVFW { _TOVFW { w : self } } # [ doc = "Bit 23 - TimeStamp Interrupt Disable" ] # [ inline ] pub fn tstp ( & mut self ) -> _TSTPW { _TSTPW { w : self } } # [ doc = "Bit 24 - CRC Error Interrupt Disable" ] # [ inline ] pub fn cerr ( & mut self ) -> _CERRW { _CERRW { w : self } } # [ doc = "Bit 25 - Stuffing Error Interrupt Disable" ] # [ inline ] pub fn serr ( & mut self ) -> _SERRW { _SERRW { w : self } } # [ doc = "Bit 26 - Acknowledgment Error Interrupt Disable" ] # [ inline ] pub fn aerr ( & mut self ) -> _AERRW { _AERRW { w : self } } # [ doc = "Bit 27 - Form Error Interrupt Disable" ] # [ inline ] pub fn ferr ( & mut self ) -> _FERRW { _FERRW { w : self } } # [ doc = "Bit 28 - Bit Error Interrupt Disable" ] # [ inline ] pub fn berr ( & mut self ) -> _BERRW { _BERRW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 MB0R { bits : bool , } impl MB0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB1R { bits : bool , } impl MB1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB2R { bits : bool , } impl MB2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB3R { bits : bool , } impl MB3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB4R { bits : bool , } impl MB4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB5R { bits : bool , } impl MB5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB6R { bits : bool , } impl MB6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB7R { bits : bool , } impl MB7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRAR { bits : bool , } impl ERRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WARNR { bits : bool , } impl WARNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRPR { bits : bool , } impl ERRPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BOFFR { bits : bool , } impl BOFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLEEPR { bits : bool , } impl SLEEPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAKEUPR { bits : bool , } impl WAKEUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TOVFR { bits : bool , } impl TOVFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTPR { bits : bool , } impl TSTPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CERRR { bits : bool , } impl CERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SERRR { bits : bool , } impl SERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct AERRR { bits : bool , } impl AERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FERRR { bits : bool , } impl FERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ( ) } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Mailbox 0 Interrupt Mask" ] # [ inline ] pub fn mb0 ( & self ) -> MB0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB0R { bits } } # [ doc = "Bit 1 - Mailbox 1 Interrupt Mask" ] # [ inline ] pub fn mb1 ( & self ) -> MB1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB1R { bits } } # [ doc = "Bit 2 - Mailbox 2 Interrupt Mask" ] # [ inline ] pub fn mb2 ( & self ) -> MB2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB2R { bits } } # [ doc = "Bit 3 - Mailbox 3 Interrupt Mask" ] # [ inline ] pub fn mb3 ( & self ) -> MB3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB3R { bits } } # [ doc = "Bit 4 - Mailbox 4 Interrupt Mask" ] # [ inline ] pub fn mb4 ( & self ) -> MB4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB4R { bits } } # [ doc = "Bit 5 - Mailbox 5 Interrupt Mask" ] # [ inline ] pub fn mb5 ( & self ) -> MB5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB5R { bits } } # [ doc = "Bit 6 - Mailbox 6 Interrupt Mask" ] # [ inline ] pub fn mb6 ( & self ) -> MB6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB6R { bits } } # [ doc = "Bit 7 - Mailbox 7 Interrupt Mask" ] # [ inline ] pub fn mb7 ( & self ) -> MB7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB7R { bits } } # [ doc = "Bit 16 - Error Active Mode Interrupt Mask" ] # [ inline ] pub fn erra ( & self ) -> ERRAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRAR { bits } } # [ doc = "Bit 17 - Warning Limit Interrupt Mask" ] # [ inline ] pub fn warn ( & self ) -> WARNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WARNR { bits } } # [ doc = "Bit 18 - Error Passive Mode Interrupt Mask" ] # [ inline ] pub fn errp ( & self ) -> ERRPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRPR { bits } } # [ doc = "Bit 19 - Bus Off Mode Interrupt Mask" ] # [ inline ] pub fn boff ( & self ) -> BOFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BOFFR { bits } } # [ doc = "Bit 20 - Sleep Interrupt Mask" ] # [ inline ] pub fn sleep ( & self ) -> SLEEPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLEEPR { bits } } # [ doc = "Bit 21 - Wakeup Interrupt Mask" ] # [ inline ] pub fn wakeup ( & self ) -> WAKEUPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAKEUPR { bits } } # [ doc = "Bit 22 - Timer Overflow Interrupt Mask" ] # [ inline ] pub fn tovf ( & self ) -> TOVFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TOVFR { bits } } # [ doc = "Bit 23 - Timestamp Interrupt Mask" ] # [ inline ] pub fn tstp ( & self ) -> TSTPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTPR { bits } } # [ doc = "Bit 24 - CRC Error Interrupt Mask" ] # [ inline ] pub fn cerr ( & self ) -> CERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CERRR { bits } } # [ doc = "Bit 25 - Stuffing Error Interrupt Mask" ] # [ inline ] pub fn serr ( & self ) -> SERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SERRR { bits } } # [ doc = "Bit 26 - Acknowledgment Error Interrupt Mask" ] # [ inline ] pub fn aerr ( & self ) -> AERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AERRR { bits } } # [ doc = "Bit 27 - Form Error Interrupt Mask" ] # [ inline ] pub fn ferr ( & self ) -> FERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FERRR { bits } } # [ doc = "Bit 28 - Bit Error Interrupt Mask" ] # [ inline ] pub fn berr ( & self ) -> BERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BERRR { bits } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 MB0R { bits : bool , } impl MB0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB1R { bits : bool , } impl MB1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB2R { bits : bool , } impl MB2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB3R { bits : bool , } impl MB3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB4R { bits : bool , } impl MB4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB5R { bits : bool , } impl MB5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB6R { bits : bool , } impl MB6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB7R { bits : bool , } impl MB7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRAR { bits : bool , } impl ERRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WARNR { bits : bool , } impl WARNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRPR { bits : bool , } impl ERRPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BOFFR { bits : bool , } impl BOFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLEEPR { bits : bool , } impl SLEEPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAKEUPR { bits : bool , } impl WAKEUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TOVFR { bits : bool , } impl TOVFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTPR { bits : bool , } impl TSTPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CERRR { bits : bool , } impl CERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SERRR { bits : bool , } impl SERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct AERRR { bits : bool , } impl AERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FERRR { bits : bool , } impl FERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 RBSYR { bits : bool , } impl RBSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TBSYR { bits : bool , } impl TBSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVLSYR { bits : bool , } impl OVLSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Mailbox 0 Event" ] # [ inline ] pub fn mb0 ( & self ) -> MB0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB0R { bits } } # [ doc = "Bit 1 - Mailbox 1 Event" ] # [ inline ] pub fn mb1 ( & self ) -> MB1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB1R { bits } } # [ doc = "Bit 2 - Mailbox 2 Event" ] # [ inline ] pub fn mb2 ( & self ) -> MB2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB2R { bits } } # [ doc = "Bit 3 - Mailbox 3 Event" ] # [ inline ] pub fn mb3 ( & self ) -> MB3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB3R { bits } } # [ doc = "Bit 4 - Mailbox 4 Event" ] # [ inline ] pub fn mb4 ( & self ) -> MB4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB4R { bits } } # [ doc = "Bit 5 - Mailbox 5 Event" ] # [ inline ] pub fn mb5 ( & self ) -> MB5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB5R { bits } } # [ doc = "Bit 6 - Mailbox 6 Event" ] # [ inline ] pub fn mb6 ( & self ) -> MB6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB6R { bits } } # [ doc = "Bit 7 - Mailbox 7 Event" ] # [ inline ] pub fn mb7 ( & self ) -> MB7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB7R { bits } } # [ doc = "Bit 16 - Error Active Mode" ] # [ inline ] pub fn erra ( & self ) -> ERRAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRAR { bits } } # [ doc = "Bit 17 - Warning Limit" ] # [ inline ] pub fn warn ( & self ) -> WARNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WARNR { bits } } # [ doc = "Bit 18 - Error Passive Mode" ] # [ inline ] pub fn errp ( & self ) -> ERRPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRPR { bits } } # [ doc = "Bit 19 - Bus Off Mode" ] # [ inline ] pub fn boff ( & self ) -> BOFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BOFFR { bits } } # [ doc = "Bit 20 - CAN controller in Low power Mode" ] # [ inline ] pub fn sleep ( & self ) -> SLEEPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLEEPR { bits } } # [ doc = "Bit 21 - CAN controller is not in Low power Mode" ] # [ inline ] pub fn wakeup ( & self ) -> WAKEUPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAKEUPR { bits } } # [ doc = "Bit 22 - Timer Overflow" ] # [ inline ] pub fn tovf ( & self ) -> TOVFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TOVFR { bits } } # [ doc = "Bit 23" ] # [ inline ] pub fn tstp ( & self ) -> TSTPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTPR { bits } } # [ doc = "Bit 24 - Mailbox CRC Error" ] # [ inline ] pub fn cerr ( & self ) -> CERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CERRR { bits } } # [ doc = "Bit 25 - Mailbox Stuffing Error" ] # [ inline ] pub fn serr ( & self ) -> SERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SERRR { bits } } # [ doc = "Bit 26 - Acknowledgment Error" ] # [ inline ] pub fn aerr ( & self ) -> AERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AERRR { bits } } # [ doc = "Bit 27 - Form Error" ] # [ inline ] pub fn ferr ( & self ) -> FERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FERRR { bits } } # [ doc = "Bit 28 - Bit Error" ] # [ inline ] pub fn berr ( & self ) -> BERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BERRR { bits } } # [ doc = "Bit 29 - Receiver busy" ] # [ inline ] pub fn rbsy ( & self ) -> RBSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RBSYR { bits } } # [ doc = "Bit 30 - Transmitter busy" ] # [ inline ] pub fn tbsy ( & self ) -> TBSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TBSYR { bits } } # [ doc = "Bit 31 - Overload busy" ] # [ inline ] pub fn ovlsy ( & self ) -> OVLSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVLSYR { bits } } } } # [ doc = "Baudrate Register" ] pub struct BR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Baudrate Register" ] pub mod br { # [ 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 :: BR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 PHASE2R { bits : u8 , } impl PHASE2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PHASE1R { bits : u8 , } impl PHASE1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PROPAGR { bits : u8 , } impl PROPAGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct SJWR { bits : u8 , } impl SJWR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct BRPR { bits : u8 , } impl BRPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SMP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMPR { # [ doc = "The incoming bit stream is sampled once at sample point." ] ONCE , # [ doc = "The incoming bit stream is sampled three times with a period of a MCK clock period, centered on sample point." ] THREE } impl SMPR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMPR :: ONCE => false , SMPR :: THREE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMPR { match value { false => SMPR :: ONCE , true => SMPR :: THREE , } } # [ doc = "Checks if the value of the field is `ONCE`" ] # [ inline ] pub fn is_once ( & self ) -> bool { * self == SMPR :: ONCE } # [ doc = "Checks if the value of the field is `THREE`" ] # [ inline ] pub fn is_three ( & self ) -> bool { * self == SMPR :: THREE } } # [ doc = r" Proxy" ] pub struct _PHASE2W < 'a > { w : & 'a mut W , } impl < 'a > _PHASE2W < '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 _PHASE1W < 'a > { w : & 'a mut W , } impl < 'a > _PHASE1W < '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 _PROPAGW < 'a > { w : & 'a mut W , } impl < 'a > _PROPAGW < '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 _SJWW < 'a > { w : & 'a mut W , } impl < 'a > _SJWW < '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 _BRPW < 'a > { w : & 'a mut W , } impl < 'a > _BRPW < '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 = "Values that can be written to the field `SMP`" ] pub enum SMPW { # [ doc = "The incoming bit stream is sampled once at sample point." ] ONCE , # [ doc = "The incoming bit stream is sampled three times with a period of a MCK clock period, centered on sample point." ] THREE } impl SMPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SMPW :: ONCE => false , SMPW :: THREE => true } } } # [ doc = r" Proxy" ] pub struct _SMPW < 'a > { w : & 'a mut W , } impl < 'a > _SMPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SMPW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The incoming bit stream is sampled once at sample point." ] # [ inline ] pub fn once ( self ) -> & 'a mut W { self . variant ( SMPW :: ONCE ) } # [ doc = "The incoming bit stream is sampled three times with a period of a MCK clock period, centered on sample point." ] # [ inline ] pub fn three ( self ) -> & 'a mut W { self . variant ( SMPW :: THREE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:2 - Phase 2 segment" ] # [ inline ] pub fn phase2 ( & self ) -> PHASE2R { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PHASE2R { bits } } # [ doc = "Bits 4:6 - Phase 1 segment" ] # [ inline ] pub fn phase1 ( & self ) -> PHASE1R { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PHASE1R { bits } } # [ doc = "Bits 8:10 - Programming time segment" ] # [ inline ] pub fn propag ( & self ) -> PROPAGR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PROPAGR { bits } } # [ doc = "Bits 12:13 - Re-synchronization jump width" ] # [ inline ] pub fn sjw ( & self ) -> SJWR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SJWR { bits } } # [ doc = "Bits 16:22 - Baudrate Prescaler." ] # [ inline ] pub fn brp ( & self ) -> BRPR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BRPR { bits } } # [ doc = "Bit 24 - Sampling Mode" ] # [ inline ] pub fn smp ( & self ) -> SMPR { SMPR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } 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 - Phase 2 segment" ] # [ inline ] pub fn phase2 ( & mut self ) -> _PHASE2W { _PHASE2W { w : self } } # [ doc = "Bits 4:6 - Phase 1 segment" ] # [ inline ] pub fn phase1 ( & mut self ) -> _PHASE1W { _PHASE1W { w : self } } # [ doc = "Bits 8:10 - Programming time segment" ] # [ inline ] pub fn propag ( & mut self ) -> _PROPAGW { _PROPAGW { w : self } } # [ doc = "Bits 12:13 - Re-synchronization jump width" ] # [ inline ] pub fn sjw ( & mut self ) -> _SJWW { _SJWW { w : self } } # [ doc = "Bits 16:22 - Baudrate Prescaler." ] # [ inline ] pub fn brp ( & mut self ) -> _BRPW { _BRPW { w : self } } # [ doc = "Bit 24 - Sampling Mode" ] # [ inline ] pub fn smp ( & mut self ) -> _SMPW { _SMPW { w : self } } } } # [ doc = "Timer Register" ] pub struct TIM { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Timer Register" ] pub mod tim { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: TIM { # [ 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 TIMERR { bits : u16 , } impl TIMERR { # [ 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 - Timer" ] # [ inline ] pub fn timer ( & self ) -> TIMERR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TIMERR { bits } } } } # [ doc = "Timestamp Register" ] pub struct TIMESTP { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Timestamp Register" ] pub mod timestp { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: TIMESTP { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 - Timestamp" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } } } # [ doc = "Error Counter Register" ] pub struct ECR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Error Counter Register" ] pub mod ecr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECR { # [ 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 RECR { bits : u8 , } impl RECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TECR { bits : u8 , } impl TECR { # [ 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 - Receive Error Counter" ] # [ inline ] pub fn rec ( & self ) -> RECR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RECR { bits } } # [ doc = "Bits 16:23 - Transmit Error Counter" ] # [ inline ] pub fn tec ( & self ) -> TECR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TECR { bits } } } } # [ doc = "Transfer Command Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Command Register" ] pub mod tcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: TCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMRSTW < 'a > { w : & 'a mut W , } impl < 'a > _TIMRSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transfer Request for Mailbox 0" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Transfer Request for Mailbox 1" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Transfer Request for Mailbox 2" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Transfer Request for Mailbox 3" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Transfer Request for Mailbox 4" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Transfer Request for Mailbox 5" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Transfer Request for Mailbox 6" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Transfer Request for Mailbox 7" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } # [ doc = "Bit 31 - Timer Reset" ] # [ inline ] pub fn timrst ( & mut self ) -> _TIMRSTW { _TIMRSTW { w : self } } } } # [ doc = "Abort Command Register" ] pub struct ACR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Abort Command Register" ] pub mod acr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ACR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Abort Request for Mailbox 0" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Abort Request for Mailbox 1" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Abort Request for Mailbox 2" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Abort Request for Mailbox 3" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Abort Request for Mailbox 4" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Abort Request for Mailbox 5" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Abort Request for Mailbox 6" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Abort Request for Mailbox 7" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - SPI Write Protection Key Password" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - SPI Write Protection Key Password" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u8 , } impl WPVSRCR { # [ 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 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:15 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WPVSRCR { bits } } } } # [ doc = "Mailbox Mode Register (MB = 0)" ] pub struct MMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 0)" ] pub mod mmr0 { # [ 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 :: MMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 0)" ] pub struct MAM0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 0)" ] pub mod mam0 { # [ 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 :: MAM0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 0)" ] pub struct MID0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 0)" ] pub mod mid0 { # [ 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 :: MID0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 0)" ] pub struct MFID0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 0)" ] pub mod mfid0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID0 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 0)" ] pub struct MSR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 0)" ] pub mod msr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR0 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 0)" ] pub struct MDL0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 0)" ] pub mod mdl0 { # [ 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 :: MDL0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 0)" ] pub struct MDH0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 0)" ] pub mod mdh0 { # [ 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 :: MDH0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 0)" ] pub struct MCR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 0)" ] pub mod mcr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 1)" ] pub struct MMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 1)" ] pub mod mmr1 { # [ 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 :: MMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 1)" ] pub struct MAM1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 1)" ] pub mod mam1 { # [ 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 :: MAM1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 1)" ] pub struct MID1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 1)" ] pub mod mid1 { # [ 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 :: MID1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 1)" ] pub struct MFID1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 1)" ] pub mod mfid1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID1 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 1)" ] pub struct MSR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 1)" ] pub mod msr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR1 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 1)" ] pub struct MDL1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 1)" ] pub mod mdl1 { # [ 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 :: MDL1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 1)" ] pub struct MDH1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 1)" ] pub mod mdh1 { # [ 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 :: MDH1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 1)" ] pub struct MCR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 1)" ] pub mod mcr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 2)" ] pub struct MMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 2)" ] pub mod mmr2 { # [ 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 :: MMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 2)" ] pub struct MAM2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 2)" ] pub mod mam2 { # [ 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 :: MAM2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 2)" ] pub struct MID2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 2)" ] pub mod mid2 { # [ 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 :: MID2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 2)" ] pub struct MFID2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 2)" ] pub mod mfid2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID2 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 2)" ] pub struct MSR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 2)" ] pub mod msr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR2 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 2)" ] pub struct MDL2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 2)" ] pub mod mdl2 { # [ 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 :: MDL2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 2)" ] pub struct MDH2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 2)" ] pub mod mdh2 { # [ 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 :: MDH2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 2)" ] pub struct MCR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 2)" ] pub mod mcr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 3)" ] pub struct MMR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 3)" ] pub mod mmr3 { # [ 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 :: MMR3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 3)" ] pub struct MAM3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 3)" ] pub mod mam3 { # [ 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 :: MAM3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 3)" ] pub struct MID3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 3)" ] pub mod mid3 { # [ 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 :: MID3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 3)" ] pub struct MFID3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 3)" ] pub mod mfid3 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID3 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 3)" ] pub struct MSR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 3)" ] pub mod msr3 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR3 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 3)" ] pub struct MDL3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 3)" ] pub mod mdl3 { # [ 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 :: MDL3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 3)" ] pub struct MDH3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 3)" ] pub mod mdh3 { # [ 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 :: MDH3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 3)" ] pub struct MCR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 3)" ] pub mod mcr3 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR3 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 4)" ] pub struct MMR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 4)" ] pub mod mmr4 { # [ 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 :: MMR4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 4)" ] pub struct MAM4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 4)" ] pub mod mam4 { # [ 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 :: MAM4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 4)" ] pub struct MID4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 4)" ] pub mod mid4 { # [ 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 :: MID4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 4)" ] pub struct MFID4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 4)" ] pub mod mfid4 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID4 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 4)" ] pub struct MSR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 4)" ] pub mod msr4 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR4 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 4)" ] pub struct MDL4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 4)" ] pub mod mdl4 { # [ 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 :: MDL4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 4)" ] pub struct MDH4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 4)" ] pub mod mdh4 { # [ 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 :: MDH4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 4)" ] pub struct MCR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 4)" ] pub mod mcr4 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR4 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 5)" ] pub struct MMR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 5)" ] pub mod mmr5 { # [ 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 :: MMR5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 5)" ] pub struct MAM5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 5)" ] pub mod mam5 { # [ 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 :: MAM5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 5)" ] pub struct MID5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 5)" ] pub mod mid5 { # [ 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 :: MID5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 5)" ] pub struct MFID5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 5)" ] pub mod mfid5 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID5 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 5)" ] pub struct MSR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 5)" ] pub mod msr5 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR5 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 5)" ] pub struct MDL5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 5)" ] pub mod mdl5 { # [ 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 :: MDL5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 5)" ] pub struct MDH5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 5)" ] pub mod mdh5 { # [ 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 :: MDH5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 5)" ] pub struct MCR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 5)" ] pub mod mcr5 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR5 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 6)" ] pub struct MMR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 6)" ] pub mod mmr6 { # [ 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 :: MMR6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 6)" ] pub struct MAM6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 6)" ] pub mod mam6 { # [ 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 :: MAM6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 6)" ] pub struct MID6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 6)" ] pub mod mid6 { # [ 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 :: MID6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 6)" ] pub struct MFID6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 6)" ] pub mod mfid6 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID6 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 6)" ] pub struct MSR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 6)" ] pub mod msr6 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR6 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 6)" ] pub struct MDL6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 6)" ] pub mod mdl6 { # [ 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 :: MDL6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 6)" ] pub struct MDH6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 6)" ] pub mod mdh6 { # [ 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 :: MDH6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 6)" ] pub struct MCR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 6)" ] pub mod mcr6 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR6 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 7)" ] pub struct MMR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 7)" ] pub mod mmr7 { # [ 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 :: MMR7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 7)" ] pub struct MAM7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 7)" ] pub mod mam7 { # [ 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 :: MAM7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 7)" ] pub struct MID7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 7)" ] pub mod mid7 { # [ 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 :: MID7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 7)" ] pub struct MFID7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 7)" ] pub mod mfid7 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID7 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 7)" ] pub struct MSR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 7)" ] pub mod msr7 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR7 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 7)" ] pub struct MDL7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 7)" ] pub mod mdl7 { # [ 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 :: MDL7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 7)" ] pub struct MDH7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 7)" ] pub mod mdh7 { # [ 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 :: MDH7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 7)" ] pub struct MCR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 7)" ] pub mod mcr7 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR7 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } } # [ doc = "Controller Area Network 1" ] pub struct CAN1 { _marker : PhantomData < * const ( ) > } unsafe impl Send for CAN1 { } impl CAN1 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const can1 :: RegisterBlock { 0x400b_8000 as * const _ } } impl Deref for CAN1 { type Target = can1 :: RegisterBlock ; fn deref ( & self ) -> & can1 :: RegisterBlock { unsafe { & * CAN1 :: ptr ( ) } } } # [ doc = "Controller Area Network 1" ] pub mod can1 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Mode Register" ] pub mr : MR , # [ doc = "0x04 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x08 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x0c - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x10 - Status Register" ] pub sr : SR , # [ doc = "0x14 - Baudrate Register" ] pub br : BR , # [ doc = "0x18 - Timer Register" ] pub tim : TIM , # [ doc = "0x1c - Timestamp Register" ] pub timestp : TIMESTP , # [ doc = "0x20 - Error Counter Register" ] pub ecr : ECR , # [ doc = "0x24 - Transfer Command Register" ] pub tcr : TCR , # [ doc = "0x28 - Abort Command Register" ] pub acr : ACR , _reserved11 : [ u8 ; 184usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , _reserved13 : [ u8 ; 276usize ] , # [ doc = "0x200 - Mailbox Mode Register (MB = 0)" ] pub mmr0 : MMR0 , # [ doc = "0x204 - Mailbox Acceptance Mask Register (MB = 0)" ] pub mam0 : MAM0 , # [ doc = "0x208 - Mailbox ID Register (MB = 0)" ] pub mid0 : MID0 , # [ doc = "0x20c - Mailbox Family ID Register (MB = 0)" ] pub mfid0 : MFID0 , # [ doc = "0x210 - Mailbox Status Register (MB = 0)" ] pub msr0 : MSR0 , # [ doc = "0x214 - Mailbox Data Low Register (MB = 0)" ] pub mdl0 : MDL0 , # [ doc = "0x218 - Mailbox Data High Register (MB = 0)" ] pub mdh0 : MDH0 , # [ doc = "0x21c - Mailbox Control Register (MB = 0)" ] pub mcr0 : MCR0 , # [ doc = "0x220 - Mailbox Mode Register (MB = 1)" ] pub mmr1 : MMR1 , # [ doc = "0x224 - Mailbox Acceptance Mask Register (MB = 1)" ] pub mam1 : MAM1 , # [ doc = "0x228 - Mailbox ID Register (MB = 1)" ] pub mid1 : MID1 , # [ doc = "0x22c - Mailbox Family ID Register (MB = 1)" ] pub mfid1 : MFID1 , # [ doc = "0x230 - Mailbox Status Register (MB = 1)" ] pub msr1 : MSR1 , # [ doc = "0x234 - Mailbox Data Low Register (MB = 1)" ] pub mdl1 : MDL1 , # [ doc = "0x238 - Mailbox Data High Register (MB = 1)" ] pub mdh1 : MDH1 , # [ doc = "0x23c - Mailbox Control Register (MB = 1)" ] pub mcr1 : MCR1 , # [ doc = "0x240 - Mailbox Mode Register (MB = 2)" ] pub mmr2 : MMR2 , # [ doc = "0x244 - Mailbox Acceptance Mask Register (MB = 2)" ] pub mam2 : MAM2 , # [ doc = "0x248 - Mailbox ID Register (MB = 2)" ] pub mid2 : MID2 , # [ doc = "0x24c - Mailbox Family ID Register (MB = 2)" ] pub mfid2 : MFID2 , # [ doc = "0x250 - Mailbox Status Register (MB = 2)" ] pub msr2 : MSR2 , # [ doc = "0x254 - Mailbox Data Low Register (MB = 2)" ] pub mdl2 : MDL2 , # [ doc = "0x258 - Mailbox Data High Register (MB = 2)" ] pub mdh2 : MDH2 , # [ doc = "0x25c - Mailbox Control Register (MB = 2)" ] pub mcr2 : MCR2 , # [ doc = "0x260 - Mailbox Mode Register (MB = 3)" ] pub mmr3 : MMR3 , # [ doc = "0x264 - Mailbox Acceptance Mask Register (MB = 3)" ] pub mam3 : MAM3 , # [ doc = "0x268 - Mailbox ID Register (MB = 3)" ] pub mid3 : MID3 , # [ doc = "0x26c - Mailbox Family ID Register (MB = 3)" ] pub mfid3 : MFID3 , # [ doc = "0x270 - Mailbox Status Register (MB = 3)" ] pub msr3 : MSR3 , # [ doc = "0x274 - Mailbox Data Low Register (MB = 3)" ] pub mdl3 : MDL3 , # [ doc = "0x278 - Mailbox Data High Register (MB = 3)" ] pub mdh3 : MDH3 , # [ doc = "0x27c - Mailbox Control Register (MB = 3)" ] pub mcr3 : MCR3 , # [ doc = "0x280 - Mailbox Mode Register (MB = 4)" ] pub mmr4 : MMR4 , # [ doc = "0x284 - Mailbox Acceptance Mask Register (MB = 4)" ] pub mam4 : MAM4 , # [ doc = "0x288 - Mailbox ID Register (MB = 4)" ] pub mid4 : MID4 , # [ doc = "0x28c - Mailbox Family ID Register (MB = 4)" ] pub mfid4 : MFID4 , # [ doc = "0x290 - Mailbox Status Register (MB = 4)" ] pub msr4 : MSR4 , # [ doc = "0x294 - Mailbox Data Low Register (MB = 4)" ] pub mdl4 : MDL4 , # [ doc = "0x298 - Mailbox Data High Register (MB = 4)" ] pub mdh4 : MDH4 , # [ doc = "0x29c - Mailbox Control Register (MB = 4)" ] pub mcr4 : MCR4 , # [ doc = "0x2a0 - Mailbox Mode Register (MB = 5)" ] pub mmr5 : MMR5 , # [ doc = "0x2a4 - Mailbox Acceptance Mask Register (MB = 5)" ] pub mam5 : MAM5 , # [ doc = "0x2a8 - Mailbox ID Register (MB = 5)" ] pub mid5 : MID5 , # [ doc = "0x2ac - Mailbox Family ID Register (MB = 5)" ] pub mfid5 : MFID5 , # [ doc = "0x2b0 - Mailbox Status Register (MB = 5)" ] pub msr5 : MSR5 , # [ doc = "0x2b4 - Mailbox Data Low Register (MB = 5)" ] pub mdl5 : MDL5 , # [ doc = "0x2b8 - Mailbox Data High Register (MB = 5)" ] pub mdh5 : MDH5 , # [ doc = "0x2bc - Mailbox Control Register (MB = 5)" ] pub mcr5 : MCR5 , # [ doc = "0x2c0 - Mailbox Mode Register (MB = 6)" ] pub mmr6 : MMR6 , # [ doc = "0x2c4 - Mailbox Acceptance Mask Register (MB = 6)" ] pub mam6 : MAM6 , # [ doc = "0x2c8 - Mailbox ID Register (MB = 6)" ] pub mid6 : MID6 , # [ doc = "0x2cc - Mailbox Family ID Register (MB = 6)" ] pub mfid6 : MFID6 , # [ doc = "0x2d0 - Mailbox Status Register (MB = 6)" ] pub msr6 : MSR6 , # [ doc = "0x2d4 - Mailbox Data Low Register (MB = 6)" ] pub mdl6 : MDL6 , # [ doc = "0x2d8 - Mailbox Data High Register (MB = 6)" ] pub mdh6 : MDH6 , # [ doc = "0x2dc - Mailbox Control Register (MB = 6)" ] pub mcr6 : MCR6 , # [ doc = "0x2e0 - Mailbox Mode Register (MB = 7)" ] pub mmr7 : MMR7 , # [ doc = "0x2e4 - Mailbox Acceptance Mask Register (MB = 7)" ] pub mam7 : MAM7 , # [ doc = "0x2e8 - Mailbox ID Register (MB = 7)" ] pub mid7 : MID7 , # [ doc = "0x2ec - Mailbox Family ID Register (MB = 7)" ] pub mfid7 : MFID7 , # [ doc = "0x2f0 - Mailbox Status Register (MB = 7)" ] pub msr7 : MSR7 , # [ doc = "0x2f4 - Mailbox Data Low Register (MB = 7)" ] pub mdl7 : MDL7 , # [ doc = "0x2f8 - Mailbox Data High Register (MB = 7)" ] pub mdh7 : MDH7 , # [ doc = "0x2fc - Mailbox Control Register (MB = 7)" ] pub mcr7 : MCR7 , } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CANENR { bits : bool , } impl CANENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LPMR { bits : bool , } impl LPMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ABMR { bits : bool , } impl ABMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVLR { bits : bool , } impl OVLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TEOFR { bits : bool , } impl TEOFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TTMR { bits : bool , } impl TTMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TIMFRZR { bits : bool , } impl TIMFRZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRPTR { bits : bool , } impl DRPTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `RXSYNC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RXSYNCR { # [ doc = "Rx Signal with Double Synchro Stages (2 Positive Edges)" ] DOUBLE_PP , # [ doc = "Rx Signal with Double Synchro Stages (One Positive Edge and One Negative Edge)" ] DOUBLE_PN , # [ doc = "Rx Signal with Single Synchro Stage (Positive Edge)" ] SINGLE_P , # [ doc = "Rx Signal with No Synchro Stage" ] NONE , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl RXSYNCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RXSYNCR :: DOUBLE_PP => 0 , RXSYNCR :: DOUBLE_PN => 0x01 , RXSYNCR :: SINGLE_P => 0x02 , RXSYNCR :: NONE => 0x03 , RXSYNCR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RXSYNCR { match value { 0 => RXSYNCR :: DOUBLE_PP , 1 => RXSYNCR :: DOUBLE_PN , 2 => RXSYNCR :: SINGLE_P , 3 => RXSYNCR :: NONE , i => RXSYNCR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DOUBLE_PP`" ] # [ inline ] pub fn is_double_pp ( & self ) -> bool { * self == RXSYNCR :: DOUBLE_PP } # [ doc = "Checks if the value of the field is `DOUBLE_PN`" ] # [ inline ] pub fn is_double_pn ( & self ) -> bool { * self == RXSYNCR :: DOUBLE_PN } # [ doc = "Checks if the value of the field is `SINGLE_P`" ] # [ inline ] pub fn is_single_p ( & self ) -> bool { * self == RXSYNCR :: SINGLE_P } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == RXSYNCR :: NONE } } # [ doc = r" Proxy" ] pub struct _CANENW < 'a > { w : & 'a mut W , } impl < 'a > _CANENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LPMW < 'a > { w : & 'a mut W , } impl < 'a > _LPMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ABMW < 'a > { w : & 'a mut W , } impl < 'a > _ABMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVLW < 'a > { w : & 'a mut W , } impl < 'a > _OVLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TEOFW < 'a > { w : & 'a mut W , } impl < 'a > _TEOFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TTMW < 'a > { w : & 'a mut W , } impl < 'a > _TTMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMFRZW < 'a > { w : & 'a mut W , } impl < 'a > _TIMFRZW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRPTW < 'a > { w : & 'a mut W , } impl < 'a > _DRPTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `RXSYNC`" ] pub enum RXSYNCW { # [ doc = "Rx Signal with Double Synchro Stages (2 Positive Edges)" ] DOUBLE_PP , # [ doc = "Rx Signal with Double Synchro Stages (One Positive Edge and One Negative Edge)" ] DOUBLE_PN , # [ doc = "Rx Signal with Single Synchro Stage (Positive Edge)" ] SINGLE_P , # [ doc = "Rx Signal with No Synchro Stage" ] NONE } impl RXSYNCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { RXSYNCW :: DOUBLE_PP => 0 , RXSYNCW :: DOUBLE_PN => 1 , RXSYNCW :: SINGLE_P => 2 , RXSYNCW :: NONE => 3 } } } # [ doc = r" Proxy" ] pub struct _RXSYNCW < 'a > { w : & 'a mut W , } impl < 'a > _RXSYNCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RXSYNCW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Rx Signal with Double Synchro Stages (2 Positive Edges)" ] # [ inline ] pub fn double_pp ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: DOUBLE_PP ) } # [ doc = "Rx Signal with Double Synchro Stages (One Positive Edge and One Negative Edge)" ] # [ inline ] pub fn double_pn ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: DOUBLE_PN ) } # [ doc = "Rx Signal with Single Synchro Stage (Positive Edge)" ] # [ inline ] pub fn single_p ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: SINGLE_P ) } # [ doc = "Rx Signal with No Synchro Stage" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( RXSYNCW :: NONE ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - CAN Controller Enable" ] # [ inline ] pub fn canen ( & self ) -> CANENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CANENR { bits } } # [ doc = "Bit 1 - Disable/Enable Low Power Mode" ] # [ inline ] pub fn lpm ( & self ) -> LPMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LPMR { bits } } # [ doc = "Bit 2 - Disable/Enable Autobaud/Listen mode" ] # [ inline ] pub fn abm ( & self ) -> ABMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ABMR { bits } } # [ doc = "Bit 3 - Disable/Enable Overload Frame" ] # [ inline ] pub fn ovl ( & self ) -> OVLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVLR { bits } } # [ doc = "Bit 4 - Timestamp messages at each end of Frame" ] # [ inline ] pub fn teof ( & self ) -> TEOFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TEOFR { bits } } # [ doc = "Bit 5 - Disable/Enable Time Triggered Mode" ] # [ inline ] pub fn ttm ( & self ) -> TTMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TTMR { bits } } # [ doc = "Bit 6 - Enable Timer Freeze" ] # [ inline ] pub fn timfrz ( & self ) -> TIMFRZR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMFRZR { bits } } # [ doc = "Bit 7 - Disable Repeat" ] # [ inline ] pub fn drpt ( & self ) -> DRPTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRPTR { bits } } # [ doc = "Bits 24:26 - Reception Synchronization Stage (not readable)" ] # [ inline ] pub fn rxsync ( & self ) -> RXSYNCR { RXSYNCR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - CAN Controller Enable" ] # [ inline ] pub fn canen ( & mut self ) -> _CANENW { _CANENW { w : self } } # [ doc = "Bit 1 - Disable/Enable Low Power Mode" ] # [ inline ] pub fn lpm ( & mut self ) -> _LPMW { _LPMW { w : self } } # [ doc = "Bit 2 - Disable/Enable Autobaud/Listen mode" ] # [ inline ] pub fn abm ( & mut self ) -> _ABMW { _ABMW { w : self } } # [ doc = "Bit 3 - Disable/Enable Overload Frame" ] # [ inline ] pub fn ovl ( & mut self ) -> _OVLW { _OVLW { w : self } } # [ doc = "Bit 4 - Timestamp messages at each end of Frame" ] # [ inline ] pub fn teof ( & mut self ) -> _TEOFW { _TEOFW { w : self } } # [ doc = "Bit 5 - Disable/Enable Time Triggered Mode" ] # [ inline ] pub fn ttm ( & mut self ) -> _TTMW { _TTMW { w : self } } # [ doc = "Bit 6 - Enable Timer Freeze" ] # [ inline ] pub fn timfrz ( & mut self ) -> _TIMFRZW { _TIMFRZW { w : self } } # [ doc = "Bit 7 - Disable Repeat" ] # [ inline ] pub fn drpt ( & mut self ) -> _DRPTW { _DRPTW { w : self } } # [ doc = "Bits 24:26 - Reception Synchronization Stage (not readable)" ] # [ inline ] pub fn rxsync ( & mut self ) -> _RXSYNCW { _RXSYNCW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRAW < 'a > { w : & 'a mut W , } impl < 'a > _ERRAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WARNW < 'a > { w : & 'a mut W , } impl < 'a > _WARNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRPW < 'a > { w : & 'a mut W , } impl < 'a > _ERRPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BOFFW < 'a > { w : & 'a mut W , } impl < 'a > _BOFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLEEPW < 'a > { w : & 'a mut W , } impl < 'a > _SLEEPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TOVFW < 'a > { w : & 'a mut W , } impl < 'a > _TOVFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTPW < 'a > { w : & 'a mut W , } impl < 'a > _TSTPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CERRW < 'a > { w : & 'a mut W , } impl < 'a > _CERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SERRW < 'a > { w : & 'a mut W , } impl < 'a > _SERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AERRW < 'a > { w : & 'a mut W , } impl < 'a > _AERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FERRW < 'a > { w : & 'a mut W , } impl < 'a > _FERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BERRW < 'a > { w : & 'a mut W , } impl < 'a > _BERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Mailbox 0 Interrupt Enable" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Mailbox 1 Interrupt Enable" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Mailbox 2 Interrupt Enable" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Mailbox 3 Interrupt Enable" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Mailbox 4 Interrupt Enable" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Mailbox 5 Interrupt Enable" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Mailbox 6 Interrupt Enable" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Mailbox 7 Interrupt Enable" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } # [ doc = "Bit 16 - Error Active Mode Interrupt Enable" ] # [ inline ] pub fn erra ( & mut self ) -> _ERRAW { _ERRAW { w : self } } # [ doc = "Bit 17 - Warning Limit Interrupt Enable" ] # [ inline ] pub fn warn ( & mut self ) -> _WARNW { _WARNW { w : self } } # [ doc = "Bit 18 - Error Passive Mode Interrupt Enable" ] # [ inline ] pub fn errp ( & mut self ) -> _ERRPW { _ERRPW { w : self } } # [ doc = "Bit 19 - Bus Off Mode Interrupt Enable" ] # [ inline ] pub fn boff ( & mut self ) -> _BOFFW { _BOFFW { w : self } } # [ doc = "Bit 20 - Sleep Interrupt Enable" ] # [ inline ] pub fn sleep ( & mut self ) -> _SLEEPW { _SLEEPW { w : self } } # [ doc = "Bit 21 - Wakeup Interrupt Enable" ] # [ inline ] pub fn wakeup ( & mut self ) -> _WAKEUPW { _WAKEUPW { w : self } } # [ doc = "Bit 22 - Timer Overflow Interrupt Enable" ] # [ inline ] pub fn tovf ( & mut self ) -> _TOVFW { _TOVFW { w : self } } # [ doc = "Bit 23 - TimeStamp Interrupt Enable" ] # [ inline ] pub fn tstp ( & mut self ) -> _TSTPW { _TSTPW { w : self } } # [ doc = "Bit 24 - CRC Error Interrupt Enable" ] # [ inline ] pub fn cerr ( & mut self ) -> _CERRW { _CERRW { w : self } } # [ doc = "Bit 25 - Stuffing Error Interrupt Enable" ] # [ inline ] pub fn serr ( & mut self ) -> _SERRW { _SERRW { w : self } } # [ doc = "Bit 26 - Acknowledgment Error Interrupt Enable" ] # [ inline ] pub fn aerr ( & mut self ) -> _AERRW { _AERRW { w : self } } # [ doc = "Bit 27 - Form Error Interrupt Enable" ] # [ inline ] pub fn ferr ( & mut self ) -> _FERRW { _FERRW { w : self } } # [ doc = "Bit 28 - Bit Error Interrupt Enable" ] # [ inline ] pub fn berr ( & mut self ) -> _BERRW { _BERRW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRAW < 'a > { w : & 'a mut W , } impl < 'a > _ERRAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WARNW < 'a > { w : & 'a mut W , } impl < 'a > _WARNW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERRPW < 'a > { w : & 'a mut W , } impl < 'a > _ERRPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BOFFW < 'a > { w : & 'a mut W , } impl < 'a > _BOFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLEEPW < 'a > { w : & 'a mut W , } impl < 'a > _SLEEPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WAKEUPW < 'a > { w : & 'a mut W , } impl < 'a > _WAKEUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TOVFW < 'a > { w : & 'a mut W , } impl < 'a > _TOVFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TSTPW < 'a > { w : & 'a mut W , } impl < 'a > _TSTPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CERRW < 'a > { w : & 'a mut W , } impl < 'a > _CERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SERRW < 'a > { w : & 'a mut W , } impl < 'a > _SERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AERRW < 'a > { w : & 'a mut W , } impl < 'a > _AERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FERRW < 'a > { w : & 'a mut W , } impl < 'a > _FERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BERRW < 'a > { w : & 'a mut W , } impl < 'a > _BERRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Mailbox 0 Interrupt Disable" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Mailbox 1 Interrupt Disable" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Mailbox 2 Interrupt Disable" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Mailbox 3 Interrupt Disable" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Mailbox 4 Interrupt Disable" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Mailbox 5 Interrupt Disable" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Mailbox 6 Interrupt Disable" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Mailbox 7 Interrupt Disable" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } # [ doc = "Bit 16 - Error Active Mode Interrupt Disable" ] # [ inline ] pub fn erra ( & mut self ) -> _ERRAW { _ERRAW { w : self } } # [ doc = "Bit 17 - Warning Limit Interrupt Disable" ] # [ inline ] pub fn warn ( & mut self ) -> _WARNW { _WARNW { w : self } } # [ doc = "Bit 18 - Error Passive Mode Interrupt Disable" ] # [ inline ] pub fn errp ( & mut self ) -> _ERRPW { _ERRPW { w : self } } # [ doc = "Bit 19 - Bus Off Mode Interrupt Disable" ] # [ inline ] pub fn boff ( & mut self ) -> _BOFFW { _BOFFW { w : self } } # [ doc = "Bit 20 - Sleep Interrupt Disable" ] # [ inline ] pub fn sleep ( & mut self ) -> _SLEEPW { _SLEEPW { w : self } } # [ doc = "Bit 21 - Wakeup Interrupt Disable" ] # [ inline ] pub fn wakeup ( & mut self ) -> _WAKEUPW { _WAKEUPW { w : self } } # [ doc = "Bit 22 - Timer Overflow Interrupt" ] # [ inline ] pub fn tovf ( & mut self ) -> _TOVFW { _TOVFW { w : self } } # [ doc = "Bit 23 - TimeStamp Interrupt Disable" ] # [ inline ] pub fn tstp ( & mut self ) -> _TSTPW { _TSTPW { w : self } } # [ doc = "Bit 24 - CRC Error Interrupt Disable" ] # [ inline ] pub fn cerr ( & mut self ) -> _CERRW { _CERRW { w : self } } # [ doc = "Bit 25 - Stuffing Error Interrupt Disable" ] # [ inline ] pub fn serr ( & mut self ) -> _SERRW { _SERRW { w : self } } # [ doc = "Bit 26 - Acknowledgment Error Interrupt Disable" ] # [ inline ] pub fn aerr ( & mut self ) -> _AERRW { _AERRW { w : self } } # [ doc = "Bit 27 - Form Error Interrupt Disable" ] # [ inline ] pub fn ferr ( & mut self ) -> _FERRW { _FERRW { w : self } } # [ doc = "Bit 28 - Bit Error Interrupt Disable" ] # [ inline ] pub fn berr ( & mut self ) -> _BERRW { _BERRW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 MB0R { bits : bool , } impl MB0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB1R { bits : bool , } impl MB1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB2R { bits : bool , } impl MB2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB3R { bits : bool , } impl MB3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB4R { bits : bool , } impl MB4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB5R { bits : bool , } impl MB5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB6R { bits : bool , } impl MB6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB7R { bits : bool , } impl MB7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRAR { bits : bool , } impl ERRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WARNR { bits : bool , } impl WARNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRPR { bits : bool , } impl ERRPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BOFFR { bits : bool , } impl BOFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLEEPR { bits : bool , } impl SLEEPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAKEUPR { bits : bool , } impl WAKEUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TOVFR { bits : bool , } impl TOVFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTPR { bits : bool , } impl TSTPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CERRR { bits : bool , } impl CERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SERRR { bits : bool , } impl SERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct AERRR { bits : bool , } impl AERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FERRR { bits : bool , } impl FERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ( ) } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Mailbox 0 Interrupt Mask" ] # [ inline ] pub fn mb0 ( & self ) -> MB0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB0R { bits } } # [ doc = "Bit 1 - Mailbox 1 Interrupt Mask" ] # [ inline ] pub fn mb1 ( & self ) -> MB1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB1R { bits } } # [ doc = "Bit 2 - Mailbox 2 Interrupt Mask" ] # [ inline ] pub fn mb2 ( & self ) -> MB2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB2R { bits } } # [ doc = "Bit 3 - Mailbox 3 Interrupt Mask" ] # [ inline ] pub fn mb3 ( & self ) -> MB3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB3R { bits } } # [ doc = "Bit 4 - Mailbox 4 Interrupt Mask" ] # [ inline ] pub fn mb4 ( & self ) -> MB4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB4R { bits } } # [ doc = "Bit 5 - Mailbox 5 Interrupt Mask" ] # [ inline ] pub fn mb5 ( & self ) -> MB5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB5R { bits } } # [ doc = "Bit 6 - Mailbox 6 Interrupt Mask" ] # [ inline ] pub fn mb6 ( & self ) -> MB6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB6R { bits } } # [ doc = "Bit 7 - Mailbox 7 Interrupt Mask" ] # [ inline ] pub fn mb7 ( & self ) -> MB7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB7R { bits } } # [ doc = "Bit 16 - Error Active Mode Interrupt Mask" ] # [ inline ] pub fn erra ( & self ) -> ERRAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRAR { bits } } # [ doc = "Bit 17 - Warning Limit Interrupt Mask" ] # [ inline ] pub fn warn ( & self ) -> WARNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WARNR { bits } } # [ doc = "Bit 18 - Error Passive Mode Interrupt Mask" ] # [ inline ] pub fn errp ( & self ) -> ERRPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRPR { bits } } # [ doc = "Bit 19 - Bus Off Mode Interrupt Mask" ] # [ inline ] pub fn boff ( & self ) -> BOFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BOFFR { bits } } # [ doc = "Bit 20 - Sleep Interrupt Mask" ] # [ inline ] pub fn sleep ( & self ) -> SLEEPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLEEPR { bits } } # [ doc = "Bit 21 - Wakeup Interrupt Mask" ] # [ inline ] pub fn wakeup ( & self ) -> WAKEUPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAKEUPR { bits } } # [ doc = "Bit 22 - Timer Overflow Interrupt Mask" ] # [ inline ] pub fn tovf ( & self ) -> TOVFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TOVFR { bits } } # [ doc = "Bit 23 - Timestamp Interrupt Mask" ] # [ inline ] pub fn tstp ( & self ) -> TSTPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTPR { bits } } # [ doc = "Bit 24 - CRC Error Interrupt Mask" ] # [ inline ] pub fn cerr ( & self ) -> CERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CERRR { bits } } # [ doc = "Bit 25 - Stuffing Error Interrupt Mask" ] # [ inline ] pub fn serr ( & self ) -> SERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SERRR { bits } } # [ doc = "Bit 26 - Acknowledgment Error Interrupt Mask" ] # [ inline ] pub fn aerr ( & self ) -> AERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AERRR { bits } } # [ doc = "Bit 27 - Form Error Interrupt Mask" ] # [ inline ] pub fn ferr ( & self ) -> FERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FERRR { bits } } # [ doc = "Bit 28 - Bit Error Interrupt Mask" ] # [ inline ] pub fn berr ( & self ) -> BERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BERRR { bits } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 MB0R { bits : bool , } impl MB0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB1R { bits : bool , } impl MB1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB2R { bits : bool , } impl MB2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB3R { bits : bool , } impl MB3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB4R { bits : bool , } impl MB4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB5R { bits : bool , } impl MB5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB6R { bits : bool , } impl MB6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MB7R { bits : bool , } impl MB7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRAR { bits : bool , } impl ERRAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WARNR { bits : bool , } impl WARNR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERRPR { bits : bool , } impl ERRPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BOFFR { bits : bool , } impl BOFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLEEPR { bits : bool , } impl SLEEPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WAKEUPR { bits : bool , } impl WAKEUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TOVFR { bits : bool , } impl TOVFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TSTPR { bits : bool , } impl TSTPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CERRR { bits : bool , } impl CERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SERRR { bits : bool , } impl SERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct AERRR { bits : bool , } impl AERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FERRR { bits : bool , } impl FERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 RBSYR { bits : bool , } impl RBSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TBSYR { bits : bool , } impl TBSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVLSYR { bits : bool , } impl OVLSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Mailbox 0 Event" ] # [ inline ] pub fn mb0 ( & self ) -> MB0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB0R { bits } } # [ doc = "Bit 1 - Mailbox 1 Event" ] # [ inline ] pub fn mb1 ( & self ) -> MB1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB1R { bits } } # [ doc = "Bit 2 - Mailbox 2 Event" ] # [ inline ] pub fn mb2 ( & self ) -> MB2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB2R { bits } } # [ doc = "Bit 3 - Mailbox 3 Event" ] # [ inline ] pub fn mb3 ( & self ) -> MB3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB3R { bits } } # [ doc = "Bit 4 - Mailbox 4 Event" ] # [ inline ] pub fn mb4 ( & self ) -> MB4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB4R { bits } } # [ doc = "Bit 5 - Mailbox 5 Event" ] # [ inline ] pub fn mb5 ( & self ) -> MB5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB5R { bits } } # [ doc = "Bit 6 - Mailbox 6 Event" ] # [ inline ] pub fn mb6 ( & self ) -> MB6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB6R { bits } } # [ doc = "Bit 7 - Mailbox 7 Event" ] # [ inline ] pub fn mb7 ( & self ) -> MB7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MB7R { bits } } # [ doc = "Bit 16 - Error Active Mode" ] # [ inline ] pub fn erra ( & self ) -> ERRAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRAR { bits } } # [ doc = "Bit 17 - Warning Limit" ] # [ inline ] pub fn warn ( & self ) -> WARNR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WARNR { bits } } # [ doc = "Bit 18 - Error Passive Mode" ] # [ inline ] pub fn errp ( & self ) -> ERRPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERRPR { bits } } # [ doc = "Bit 19 - Bus Off Mode" ] # [ inline ] pub fn boff ( & self ) -> BOFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BOFFR { bits } } # [ doc = "Bit 20 - CAN controller in Low power Mode" ] # [ inline ] pub fn sleep ( & self ) -> SLEEPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLEEPR { bits } } # [ doc = "Bit 21 - CAN controller is not in Low power Mode" ] # [ inline ] pub fn wakeup ( & self ) -> WAKEUPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WAKEUPR { bits } } # [ doc = "Bit 22 - Timer Overflow" ] # [ inline ] pub fn tovf ( & self ) -> TOVFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TOVFR { bits } } # [ doc = "Bit 23" ] # [ inline ] pub fn tstp ( & self ) -> TSTPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSTPR { bits } } # [ doc = "Bit 24 - Mailbox CRC Error" ] # [ inline ] pub fn cerr ( & self ) -> CERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CERRR { bits } } # [ doc = "Bit 25 - Mailbox Stuffing Error" ] # [ inline ] pub fn serr ( & self ) -> SERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SERRR { bits } } # [ doc = "Bit 26 - Acknowledgment Error" ] # [ inline ] pub fn aerr ( & self ) -> AERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AERRR { bits } } # [ doc = "Bit 27 - Form Error" ] # [ inline ] pub fn ferr ( & self ) -> FERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FERRR { bits } } # [ doc = "Bit 28 - Bit Error" ] # [ inline ] pub fn berr ( & self ) -> BERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BERRR { bits } } # [ doc = "Bit 29 - Receiver busy" ] # [ inline ] pub fn rbsy ( & self ) -> RBSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RBSYR { bits } } # [ doc = "Bit 30 - Transmitter busy" ] # [ inline ] pub fn tbsy ( & self ) -> TBSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TBSYR { bits } } # [ doc = "Bit 31 - Overload busy" ] # [ inline ] pub fn ovlsy ( & self ) -> OVLSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVLSYR { bits } } } } # [ doc = "Baudrate Register" ] pub struct BR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Baudrate Register" ] pub mod br { # [ 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 :: BR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 PHASE2R { bits : u8 , } impl PHASE2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PHASE1R { bits : u8 , } impl PHASE1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PROPAGR { bits : u8 , } impl PROPAGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct SJWR { bits : u8 , } impl SJWR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct BRPR { bits : u8 , } impl BRPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SMP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMPR { # [ doc = "The incoming bit stream is sampled once at sample point." ] ONCE , # [ doc = "The incoming bit stream is sampled three times with a period of a MCK clock period, centered on sample point." ] THREE } impl SMPR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMPR :: ONCE => false , SMPR :: THREE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMPR { match value { false => SMPR :: ONCE , true => SMPR :: THREE , } } # [ doc = "Checks if the value of the field is `ONCE`" ] # [ inline ] pub fn is_once ( & self ) -> bool { * self == SMPR :: ONCE } # [ doc = "Checks if the value of the field is `THREE`" ] # [ inline ] pub fn is_three ( & self ) -> bool { * self == SMPR :: THREE } } # [ doc = r" Proxy" ] pub struct _PHASE2W < 'a > { w : & 'a mut W , } impl < 'a > _PHASE2W < '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 _PHASE1W < 'a > { w : & 'a mut W , } impl < 'a > _PHASE1W < '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 _PROPAGW < 'a > { w : & 'a mut W , } impl < 'a > _PROPAGW < '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 _SJWW < 'a > { w : & 'a mut W , } impl < 'a > _SJWW < '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 _BRPW < 'a > { w : & 'a mut W , } impl < 'a > _BRPW < '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 = "Values that can be written to the field `SMP`" ] pub enum SMPW { # [ doc = "The incoming bit stream is sampled once at sample point." ] ONCE , # [ doc = "The incoming bit stream is sampled three times with a period of a MCK clock period, centered on sample point." ] THREE } impl SMPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SMPW :: ONCE => false , SMPW :: THREE => true } } } # [ doc = r" Proxy" ] pub struct _SMPW < 'a > { w : & 'a mut W , } impl < 'a > _SMPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SMPW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The incoming bit stream is sampled once at sample point." ] # [ inline ] pub fn once ( self ) -> & 'a mut W { self . variant ( SMPW :: ONCE ) } # [ doc = "The incoming bit stream is sampled three times with a period of a MCK clock period, centered on sample point." ] # [ inline ] pub fn three ( self ) -> & 'a mut W { self . variant ( SMPW :: THREE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:2 - Phase 2 segment" ] # [ inline ] pub fn phase2 ( & self ) -> PHASE2R { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PHASE2R { bits } } # [ doc = "Bits 4:6 - Phase 1 segment" ] # [ inline ] pub fn phase1 ( & self ) -> PHASE1R { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PHASE1R { bits } } # [ doc = "Bits 8:10 - Programming time segment" ] # [ inline ] pub fn propag ( & self ) -> PROPAGR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PROPAGR { bits } } # [ doc = "Bits 12:13 - Re-synchronization jump width" ] # [ inline ] pub fn sjw ( & self ) -> SJWR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SJWR { bits } } # [ doc = "Bits 16:22 - Baudrate Prescaler." ] # [ inline ] pub fn brp ( & self ) -> BRPR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BRPR { bits } } # [ doc = "Bit 24 - Sampling Mode" ] # [ inline ] pub fn smp ( & self ) -> SMPR { SMPR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } 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 - Phase 2 segment" ] # [ inline ] pub fn phase2 ( & mut self ) -> _PHASE2W { _PHASE2W { w : self } } # [ doc = "Bits 4:6 - Phase 1 segment" ] # [ inline ] pub fn phase1 ( & mut self ) -> _PHASE1W { _PHASE1W { w : self } } # [ doc = "Bits 8:10 - Programming time segment" ] # [ inline ] pub fn propag ( & mut self ) -> _PROPAGW { _PROPAGW { w : self } } # [ doc = "Bits 12:13 - Re-synchronization jump width" ] # [ inline ] pub fn sjw ( & mut self ) -> _SJWW { _SJWW { w : self } } # [ doc = "Bits 16:22 - Baudrate Prescaler." ] # [ inline ] pub fn brp ( & mut self ) -> _BRPW { _BRPW { w : self } } # [ doc = "Bit 24 - Sampling Mode" ] # [ inline ] pub fn smp ( & mut self ) -> _SMPW { _SMPW { w : self } } } } # [ doc = "Timer Register" ] pub struct TIM { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Timer Register" ] pub mod tim { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: TIM { # [ 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 TIMERR { bits : u16 , } impl TIMERR { # [ 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 - Timer" ] # [ inline ] pub fn timer ( & self ) -> TIMERR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TIMERR { bits } } } } # [ doc = "Timestamp Register" ] pub struct TIMESTP { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Timestamp Register" ] pub mod timestp { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: TIMESTP { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 - Timestamp" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } } } # [ doc = "Error Counter Register" ] pub struct ECR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Error Counter Register" ] pub mod ecr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECR { # [ 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 RECR { bits : u8 , } impl RECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TECR { bits : u8 , } impl TECR { # [ 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 - Receive Error Counter" ] # [ inline ] pub fn rec ( & self ) -> RECR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RECR { bits } } # [ doc = "Bits 16:23 - Transmit Error Counter" ] # [ inline ] pub fn tec ( & self ) -> TECR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TECR { bits } } } } # [ doc = "Transfer Command Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Command Register" ] pub mod tcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: TCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMRSTW < 'a > { w : & 'a mut W , } impl < 'a > _TIMRSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Transfer Request for Mailbox 0" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Transfer Request for Mailbox 1" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Transfer Request for Mailbox 2" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Transfer Request for Mailbox 3" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Transfer Request for Mailbox 4" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Transfer Request for Mailbox 5" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Transfer Request for Mailbox 6" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Transfer Request for Mailbox 7" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } # [ doc = "Bit 31 - Timer Reset" ] # [ inline ] pub fn timrst ( & mut self ) -> _TIMRSTW { _TIMRSTW { w : self } } } } # [ doc = "Abort Command Register" ] pub struct ACR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Abort Command Register" ] pub mod acr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ACR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MB0W < 'a > { w : & 'a mut W , } impl < 'a > _MB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB1W < 'a > { w : & 'a mut W , } impl < 'a > _MB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB2W < 'a > { w : & 'a mut W , } impl < 'a > _MB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB3W < 'a > { w : & 'a mut W , } impl < 'a > _MB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB4W < 'a > { w : & 'a mut W , } impl < 'a > _MB4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB5W < 'a > { w : & 'a mut W , } impl < 'a > _MB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB6W < 'a > { w : & 'a mut W , } impl < 'a > _MB6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MB7W < 'a > { w : & 'a mut W , } impl < 'a > _MB7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Abort Request for Mailbox 0" ] # [ inline ] pub fn mb0 ( & mut self ) -> _MB0W { _MB0W { w : self } } # [ doc = "Bit 1 - Abort Request for Mailbox 1" ] # [ inline ] pub fn mb1 ( & mut self ) -> _MB1W { _MB1W { w : self } } # [ doc = "Bit 2 - Abort Request for Mailbox 2" ] # [ inline ] pub fn mb2 ( & mut self ) -> _MB2W { _MB2W { w : self } } # [ doc = "Bit 3 - Abort Request for Mailbox 3" ] # [ inline ] pub fn mb3 ( & mut self ) -> _MB3W { _MB3W { w : self } } # [ doc = "Bit 4 - Abort Request for Mailbox 4" ] # [ inline ] pub fn mb4 ( & mut self ) -> _MB4W { _MB4W { w : self } } # [ doc = "Bit 5 - Abort Request for Mailbox 5" ] # [ inline ] pub fn mb5 ( & mut self ) -> _MB5W { _MB5W { w : self } } # [ doc = "Bit 6 - Abort Request for Mailbox 6" ] # [ inline ] pub fn mb6 ( & mut self ) -> _MB6W { _MB6W { w : self } } # [ doc = "Bit 7 - Abort Request for Mailbox 7" ] # [ inline ] pub fn mb7 ( & mut self ) -> _MB7W { _MB7W { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - SPI Write Protection Key Password" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protection Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - SPI Write Protection Key Password" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u8 , } impl WPVSRCR { # [ 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 0 - Write Protection Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:15 - Write Protection Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WPVSRCR { bits } } } } # [ doc = "Mailbox Mode Register (MB = 0)" ] pub struct MMR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 0)" ] pub mod mmr0 { # [ 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 :: MMR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 0)" ] pub struct MAM0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 0)" ] pub mod mam0 { # [ 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 :: MAM0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 0)" ] pub struct MID0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 0)" ] pub mod mid0 { # [ 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 :: MID0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 0)" ] pub struct MFID0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 0)" ] pub mod mfid0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID0 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 0)" ] pub struct MSR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 0)" ] pub mod msr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR0 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 0)" ] pub struct MDL0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 0)" ] pub mod mdl0 { # [ 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 :: MDL0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 0)" ] pub struct MDH0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 0)" ] pub mod mdh0 { # [ 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 :: MDH0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 0)" ] pub struct MCR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 0)" ] pub mod mcr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 1)" ] pub struct MMR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 1)" ] pub mod mmr1 { # [ 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 :: MMR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 1)" ] pub struct MAM1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 1)" ] pub mod mam1 { # [ 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 :: MAM1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 1)" ] pub struct MID1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 1)" ] pub mod mid1 { # [ 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 :: MID1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 1)" ] pub struct MFID1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 1)" ] pub mod mfid1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID1 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 1)" ] pub struct MSR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 1)" ] pub mod msr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR1 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 1)" ] pub struct MDL1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 1)" ] pub mod mdl1 { # [ 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 :: MDL1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 1)" ] pub struct MDH1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 1)" ] pub mod mdh1 { # [ 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 :: MDH1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 1)" ] pub struct MCR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 1)" ] pub mod mcr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 2)" ] pub struct MMR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 2)" ] pub mod mmr2 { # [ 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 :: MMR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 2)" ] pub struct MAM2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 2)" ] pub mod mam2 { # [ 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 :: MAM2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 2)" ] pub struct MID2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 2)" ] pub mod mid2 { # [ 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 :: MID2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 2)" ] pub struct MFID2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 2)" ] pub mod mfid2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID2 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 2)" ] pub struct MSR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 2)" ] pub mod msr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR2 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 2)" ] pub struct MDL2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 2)" ] pub mod mdl2 { # [ 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 :: MDL2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 2)" ] pub struct MDH2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 2)" ] pub mod mdh2 { # [ 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 :: MDH2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 2)" ] pub struct MCR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 2)" ] pub mod mcr2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 3)" ] pub struct MMR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 3)" ] pub mod mmr3 { # [ 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 :: MMR3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 3)" ] pub struct MAM3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 3)" ] pub mod mam3 { # [ 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 :: MAM3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 3)" ] pub struct MID3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 3)" ] pub mod mid3 { # [ 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 :: MID3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 3)" ] pub struct MFID3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 3)" ] pub mod mfid3 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID3 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 3)" ] pub struct MSR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 3)" ] pub mod msr3 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR3 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 3)" ] pub struct MDL3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 3)" ] pub mod mdl3 { # [ 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 :: MDL3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 3)" ] pub struct MDH3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 3)" ] pub mod mdh3 { # [ 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 :: MDH3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 3)" ] pub struct MCR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 3)" ] pub mod mcr3 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR3 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 4)" ] pub struct MMR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 4)" ] pub mod mmr4 { # [ 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 :: MMR4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 4)" ] pub struct MAM4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 4)" ] pub mod mam4 { # [ 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 :: MAM4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 4)" ] pub struct MID4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 4)" ] pub mod mid4 { # [ 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 :: MID4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 4)" ] pub struct MFID4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 4)" ] pub mod mfid4 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID4 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 4)" ] pub struct MSR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 4)" ] pub mod msr4 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR4 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 4)" ] pub struct MDL4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 4)" ] pub mod mdl4 { # [ 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 :: MDL4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 4)" ] pub struct MDH4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 4)" ] pub mod mdh4 { # [ 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 :: MDH4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 4)" ] pub struct MCR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 4)" ] pub mod mcr4 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR4 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 5)" ] pub struct MMR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 5)" ] pub mod mmr5 { # [ 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 :: MMR5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 5)" ] pub struct MAM5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 5)" ] pub mod mam5 { # [ 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 :: MAM5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 5)" ] pub struct MID5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 5)" ] pub mod mid5 { # [ 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 :: MID5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 5)" ] pub struct MFID5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 5)" ] pub mod mfid5 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID5 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 5)" ] pub struct MSR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 5)" ] pub mod msr5 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR5 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 5)" ] pub struct MDL5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 5)" ] pub mod mdl5 { # [ 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 :: MDL5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 5)" ] pub struct MDH5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 5)" ] pub mod mdh5 { # [ 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 :: MDH5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 5)" ] pub struct MCR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 5)" ] pub mod mcr5 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR5 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 6)" ] pub struct MMR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 6)" ] pub mod mmr6 { # [ 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 :: MMR6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 6)" ] pub struct MAM6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 6)" ] pub mod mam6 { # [ 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 :: MAM6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 6)" ] pub struct MID6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 6)" ] pub mod mid6 { # [ 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 :: MID6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 6)" ] pub struct MFID6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 6)" ] pub mod mfid6 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID6 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 6)" ] pub struct MSR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 6)" ] pub mod msr6 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR6 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 6)" ] pub struct MDL6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 6)" ] pub mod mdl6 { # [ 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 :: MDL6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 6)" ] pub struct MDH6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 6)" ] pub mod mdh6 { # [ 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 :: MDH6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 6)" ] pub struct MCR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 6)" ] pub mod mcr6 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR6 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } # [ doc = "Mailbox Mode Register (MB = 7)" ] pub struct MMR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Mode Register (MB = 7)" ] pub mod mmr7 { # [ 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 :: MMR7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MTIMEMARKR { bits : u16 , } impl MTIMEMARKR { # [ 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 PRIORR { bits : u8 , } impl PRIORR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `MOT`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOTR { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOTR :: MB_DISABLED => 0 , MOTR :: MB_RX => 0x01 , MOTR :: MB_RX_OVERWRITE => 0x02 , MOTR :: MB_TX => 0x03 , MOTR :: MB_CONSUMER => 0x04 , MOTR :: MB_PRODUCER => 0x05 , MOTR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOTR { match value { 0 => MOTR :: MB_DISABLED , 1 => MOTR :: MB_RX , 2 => MOTR :: MB_RX_OVERWRITE , 3 => MOTR :: MB_TX , 4 => MOTR :: MB_CONSUMER , 5 => MOTR :: MB_PRODUCER , i => MOTR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `MB_DISABLED`" ] # [ inline ] pub fn is_mb_disabled ( & self ) -> bool { * self == MOTR :: MB_DISABLED } # [ doc = "Checks if the value of the field is `MB_RX`" ] # [ inline ] pub fn is_mb_rx ( & self ) -> bool { * self == MOTR :: MB_RX } # [ doc = "Checks if the value of the field is `MB_RX_OVERWRITE`" ] # [ inline ] pub fn is_mb_rx_overwrite ( & self ) -> bool { * self == MOTR :: MB_RX_OVERWRITE } # [ doc = "Checks if the value of the field is `MB_TX`" ] # [ inline ] pub fn is_mb_tx ( & self ) -> bool { * self == MOTR :: MB_TX } # [ doc = "Checks if the value of the field is `MB_CONSUMER`" ] # [ inline ] pub fn is_mb_consumer ( & self ) -> bool { * self == MOTR :: MB_CONSUMER } # [ doc = "Checks if the value of the field is `MB_PRODUCER`" ] # [ inline ] pub fn is_mb_producer ( & self ) -> bool { * self == MOTR :: MB_PRODUCER } } # [ doc = r" Proxy" ] pub struct _MTIMEMARKW < 'a > { w : & 'a mut W , } impl < 'a > _MTIMEMARKW < '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 } } # [ doc = r" Proxy" ] pub struct _PRIORW < 'a > { w : & 'a mut W , } impl < 'a > _PRIORW < '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 = "Values that can be written to the field `MOT`" ] pub enum MOTW { # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] MB_DISABLED , # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] MB_RX , # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] MB_RX_OVERWRITE , # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] MB_TX , # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] MB_CONSUMER , # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] MB_PRODUCER } impl MOTW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOTW :: MB_DISABLED => 0 , MOTW :: MB_RX => 1 , MOTW :: MB_RX_OVERWRITE => 2 , MOTW :: MB_TX => 3 , MOTW :: MB_CONSUMER => 4 , MOTW :: MB_PRODUCER => 5 } } } # [ doc = r" Proxy" ] pub struct _MOTW < 'a > { w : & 'a mut W , } impl < 'a > _MOTW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOTW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Mailbox is disabled. This prevents receiving or transmitting any messages with this mailbox." ] # [ inline ] pub fn mb_disabled ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_DISABLED ) } # [ doc = "Reception Mailbox. Mailbox is configured for reception. If a message is received while the mailbox data register is full, it is discarded." ] # [ inline ] pub fn mb_rx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX ) } # [ doc = "Reception mailbox with overwrite. Mailbox is configured for reception. If a message is received while the mailbox is full, it overwrites the previous message." ] # [ inline ] pub fn mb_rx_overwrite ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_RX_OVERWRITE ) } # [ doc = "Transmit mailbox. Mailbox is configured for transmission." ] # [ inline ] pub fn mb_tx ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_TX ) } # [ doc = "Consumer Mailbox. Mailbox is configured in reception but behaves as a Transmit Mailbox, i.e., it sends a remote frame and waits for an answer." ] # [ inline ] pub fn mb_consumer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_CONSUMER ) } # [ doc = "Producer Mailbox. Mailbox is configured in transmission but also behaves like a reception mailbox, i.e., it waits to receive a Remote Frame before sending its contents." ] # [ inline ] pub fn mb_producer ( self ) -> & 'a mut W { self . variant ( MOTW :: MB_PRODUCER ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:15 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & self ) -> MTIMEMARKR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMEMARKR { bits } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & self ) -> PRIORR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRIORR { bits } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & self ) -> MOTR { MOTR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Mailbox Timemark" ] # [ inline ] pub fn mtimemark ( & mut self ) -> _MTIMEMARKW { _MTIMEMARKW { w : self } } # [ doc = "Bits 16:19 - Mailbox Priority" ] # [ inline ] pub fn prior ( & mut self ) -> _PRIORW { _PRIORW { w : self } } # [ doc = "Bits 24:26 - Mailbox Object Type" ] # [ inline ] pub fn mot ( & mut self ) -> _MOTW { _MOTW { w : self } } } } # [ doc = "Mailbox Acceptance Mask Register (MB = 7)" ] pub struct MAM7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Acceptance Mask Register (MB = 7)" ] pub mod mam7 { # [ 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 :: MAM7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox ID Register (MB = 7)" ] pub struct MID7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox ID Register (MB = 7)" ] pub mod mid7 { # [ 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 :: MID7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MIDVBR { bits : u32 , } impl MIDVBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Value of the field" ] pub struct MIDVAR { bits : u16 , } impl MIDVAR { # [ 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 MIDER { bits : bool , } impl MIDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MIDVBW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVBW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x0003_ffff ; 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 _MIDVAW < 'a > { w : & 'a mut W , } impl < 'a > _MIDVAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _MIDEW < 'a > { w : & 'a mut W , } impl < 'a > _MIDEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & self ) -> MIDVBR { let bits = { const MASK : u32 = 0x0003_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MIDVBR { bits } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & self ) -> MIDVAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MIDVAR { bits } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & self ) -> MIDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MIDER { 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:17 - Complementary bits for identifier in extended frame mode" ] # [ inline ] pub fn midv_b ( & mut self ) -> _MIDVBW { _MIDVBW { w : self } } # [ doc = "Bits 18:28 - Identifier for standard frame mode" ] # [ inline ] pub fn midv_a ( & mut self ) -> _MIDVAW { _MIDVAW { w : self } } # [ doc = "Bit 29 - Identifier Version" ] # [ inline ] pub fn mide ( & mut self ) -> _MIDEW { _MIDEW { w : self } } } } # [ doc = "Mailbox Family ID Register (MB = 7)" ] pub struct MFID7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Family ID Register (MB = 7)" ] pub mod mfid7 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MFID7 { # [ 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 MFIDR { bits : u32 , } impl MFIDR { # [ 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:28 - Family ID" ] # [ inline ] pub fn mfid ( & self ) -> MFIDR { let bits = { const MASK : u32 = 0x1fff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MFIDR { bits } } } } # [ doc = "Mailbox Status Register (MB = 7)" ] pub struct MSR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Status Register (MB = 7)" ] pub mod msr7 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MSR7 { # [ 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 MTIMESTAMPR { bits : u16 , } impl MTIMESTAMPR { # [ 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 MDLCR { bits : u8 , } impl MDLCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MRTRR { bits : bool , } impl MRTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MABTR { bits : bool , } impl MABTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MRDYR { bits : bool , } impl MRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MMIR { bits : bool , } impl MMIR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Timer value" ] # [ inline ] pub fn mtimestamp ( & self ) -> MTIMESTAMPR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MTIMESTAMPR { bits } } # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & self ) -> MDLCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MDLCR { bits } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & self ) -> MRTRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRTRR { bits } } # [ doc = "Bit 22 - Mailbox Message Abort" ] # [ inline ] pub fn mabt ( & self ) -> MABTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MABTR { bits } } # [ doc = "Bit 23 - Mailbox Ready" ] # [ inline ] pub fn mrdy ( & self ) -> MRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MRDYR { bits } } # [ doc = "Bit 24 - Mailbox Message Ignored" ] # [ inline ] pub fn mmi ( & self ) -> MMIR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MMIR { bits } } } } # [ doc = "Mailbox Data Low Register (MB = 7)" ] pub struct MDL7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data Low Register (MB = 7)" ] pub mod mdl7 { # [ 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 :: MDL7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDLR { bits : u32 , } impl MDLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDLW < 'a > { w : & 'a mut W , } impl < 'a > _MDLW < '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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & self ) -> MDLR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDLR { 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 - Message Data Low Value" ] # [ inline ] pub fn mdl ( & mut self ) -> _MDLW { _MDLW { w : self } } } } # [ doc = "Mailbox Data High Register (MB = 7)" ] pub struct MDH7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Data High Register (MB = 7)" ] pub mod mdh7 { # [ 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 :: MDH7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MDHR { bits : u32 , } impl MDHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _MDHW < 'a > { w : & 'a mut W , } impl < 'a > _MDHW < '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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & self ) -> MDHR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; MDHR { 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 - Message Data High Value" ] # [ inline ] pub fn mdh ( & mut self ) -> _MDHW { _MDHW { w : self } } } } # [ doc = "Mailbox Control Register (MB = 7)" ] pub struct MCR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mailbox Control Register (MB = 7)" ] pub mod mcr7 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MCR7 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MDLCW < 'a > { w : & 'a mut W , } impl < 'a > _MDLCW < '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 _MRTRW < 'a > { w : & 'a mut W , } impl < 'a > _MRTRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MACRW < 'a > { w : & 'a mut W , } impl < 'a > _MACRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MTCRW < 'a > { w : & 'a mut W , } impl < 'a > _MTCRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bits 16:19 - Mailbox Data Length Code" ] # [ inline ] pub fn mdlc ( & mut self ) -> _MDLCW { _MDLCW { w : self } } # [ doc = "Bit 20 - Mailbox Remote Transmission Request" ] # [ inline ] pub fn mrtr ( & mut self ) -> _MRTRW { _MRTRW { w : self } } # [ doc = "Bit 22 - Abort Request for Mailbox x" ] # [ inline ] pub fn macr ( & mut self ) -> _MACRW { _MACRW { w : self } } # [ doc = "Bit 23 - Mailbox Transfer Command" ] # [ inline ] pub fn mtcr ( & mut self ) -> _MTCRW { _MTCRW { w : self } } } } } # [ doc = "True Random Number Generator" ] pub struct TRNG { _marker : PhantomData < * const ( ) > } unsafe impl Send for TRNG { } impl TRNG { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const trng :: RegisterBlock { 0x400b_c000 as * const _ } } impl Deref for TRNG { type Target = trng :: RegisterBlock ; fn deref ( & self ) -> & trng :: RegisterBlock { unsafe { & * TRNG :: ptr ( ) } } } # [ doc = "True Random Number Generator" ] pub mod trng { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , _reserved1 : [ u8 ; 12usize ] , # [ doc = "0x10 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x14 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x18 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x1c - Interrupt Status Register" ] pub isr : ISR , _reserved5 : [ u8 ; 48usize ] , # [ doc = "0x50 - Output Data Register" ] pub odata : ODATA , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _ENABLEW < 'a > { w : & 'a mut W , } impl < 'a > _ENABLEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 : u32 ) -> & 'a mut W { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bit 0 - Enables the TRNG to provide random values" ] # [ inline ] pub fn enable ( & mut self ) -> _ENABLEW { _ENABLEW { w : self } } # [ doc = "Bits 8:31 - Security Key" ] # [ inline ] pub fn key ( & mut self ) -> _KEYW { _KEYW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DATRDYW < 'a > { w : & 'a mut W , } impl < 'a > _DATRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Data Ready Interrupt Enable" ] # [ inline ] pub fn datrdy ( & mut self ) -> _DATRDYW { _DATRDYW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DATRDYW < 'a > { w : & 'a mut W , } impl < 'a > _DATRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Data Ready Interrupt Disable" ] # [ inline ] pub fn datrdy ( & mut self ) -> _DATRDYW { _DATRDYW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 DATRDYR { bits : bool , } impl DATRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Data Ready Interrupt Mask" ] # [ inline ] pub fn datrdy ( & self ) -> DATRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DATRDYR { bits } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ 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 DATRDYR { bits : bool , } impl DATRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Data Ready" ] # [ inline ] pub fn datrdy ( & self ) -> DATRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DATRDYR { bits } } } } # [ doc = "Output Data Register" ] pub struct ODATA { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Data Register" ] pub mod odata { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ODATA { # [ 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 ODATAR { bits : u32 , } impl ODATAR { # [ 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 - Output Data" ] # [ inline ] pub fn odata ( & self ) -> ODATAR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ODATAR { bits } } } } } # [ 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 { 0x400c_0000 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 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Mode Register" ] pub mr : MR , # [ doc = "0x08 - Channel Sequence Register 1" ] pub seqr1 : SEQR1 , # [ doc = "0x0c - Channel Sequence Register 2" ] pub seqr2 : SEQR2 , # [ doc = "0x10 - Channel Enable Register" ] pub cher : CHER , # [ doc = "0x14 - Channel Disable Register" ] pub chdr : CHDR , # [ doc = "0x18 - Channel Status Register" ] pub chsr : CHSR , _reserved7 : [ u8 ; 4usize ] , # [ doc = "0x20 - Last Converted Data Register" ] pub lcdr : LCDR , # [ doc = "0x24 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x28 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x2c - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x30 - Interrupt Status Register" ] pub isr : ISR , _reserved12 : [ u8 ; 8usize ] , # [ doc = "0x3c - Overrun Status Register" ] pub over : OVER , # [ doc = "0x40 - Extended Mode Register" ] pub emr : EMR , # [ doc = "0x44 - Compare Window Register" ] pub cwr : CWR , # [ doc = "0x48 - Channel Gain Register" ] pub cgr : CGR , # [ doc = "0x4c - Channel Offset Register" ] pub cor : COR , # [ doc = "0x50 - Channel Data Register" ] pub cdr : [ CDR ; 16 ] , _reserved18 : [ u8 ; 4usize ] , # [ doc = "0x94 - Analog Control Register" ] pub acr : ACR , _reserved19 : [ u8 ; 76usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , _reserved21 : [ u8 ; 20usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , _reserved23 : [ u8 ; 8usize ] , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , _reserved25 : [ u8 ; 8usize ] , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; 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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bit 0 - Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } # [ doc = "Bit 1 - Start Conversion" ] # [ inline ] pub fn start ( & mut self ) -> _STARTW { _STARTW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TRGEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TRGENR { # [ doc = "Hardware triggers are disabled. Starting a conversion is only possible by software." ] DIS , # [ doc = "Hardware trigger selected by TRGSEL field is enabled." ] EN } impl TRGENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { TRGENR :: DIS => false , TRGENR :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> TRGENR { match value { false => TRGENR :: DIS , true => TRGENR :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == TRGENR :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == TRGENR :: EN } } # [ doc = "Possible values of the field `TRGSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TRGSELR { # [ doc = "External : ADCTRG" ] ADC_TRIG0 , # [ doc = "TIOA Output of the Timer Counter Channel 0" ] ADC_TRIG1 , # [ doc = "TIOA Output of the Timer Counter Channel 1" ] ADC_TRIG2 , # [ doc = "TIOA Output of the Timer Counter Channel 2" ] ADC_TRIG3 , # [ doc = "PWM Event Line 0" ] ADC_TRIG4 , # [ doc = "PWM Event Line 0" ] ADC_TRIG5 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TRGSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TRGSELR :: ADC_TRIG0 => 0 , TRGSELR :: ADC_TRIG1 => 0x01 , TRGSELR :: ADC_TRIG2 => 0x02 , TRGSELR :: ADC_TRIG3 => 0x03 , TRGSELR :: ADC_TRIG4 => 0x04 , TRGSELR :: ADC_TRIG5 => 0x05 , TRGSELR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TRGSELR { match value { 0 => TRGSELR :: ADC_TRIG0 , 1 => TRGSELR :: ADC_TRIG1 , 2 => TRGSELR :: ADC_TRIG2 , 3 => TRGSELR :: ADC_TRIG3 , 4 => TRGSELR :: ADC_TRIG4 , 5 => TRGSELR :: ADC_TRIG5 , i => TRGSELR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ADC_TRIG0`" ] # [ inline ] pub fn is_adc_trig0 ( & self ) -> bool { * self == TRGSELR :: ADC_TRIG0 } # [ doc = "Checks if the value of the field is `ADC_TRIG1`" ] # [ inline ] pub fn is_adc_trig1 ( & self ) -> bool { * self == TRGSELR :: ADC_TRIG1 } # [ doc = "Checks if the value of the field is `ADC_TRIG2`" ] # [ inline ] pub fn is_adc_trig2 ( & self ) -> bool { * self == TRGSELR :: ADC_TRIG2 } # [ doc = "Checks if the value of the field is `ADC_TRIG3`" ] # [ inline ] pub fn is_adc_trig3 ( & self ) -> bool { * self == TRGSELR :: ADC_TRIG3 } # [ doc = "Checks if the value of the field is `ADC_TRIG4`" ] # [ inline ] pub fn is_adc_trig4 ( & self ) -> bool { * self == TRGSELR :: ADC_TRIG4 } # [ doc = "Checks if the value of the field is `ADC_TRIG5`" ] # [ inline ] pub fn is_adc_trig5 ( & self ) -> bool { * self == TRGSELR :: ADC_TRIG5 } } # [ doc = "Possible values of the field `SLEEP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SLEEPR { # [ doc = "Normal Mode: The ADC Core and reference voltage circuitry are kept ON between conversions" ] NORMAL , # [ doc = "Sleep Mode: The wake-up time can be modified by programming FWUP bit" ] SLEEP } impl SLEEPR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SLEEPR :: NORMAL => false , SLEEPR :: SLEEP => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SLEEPR { match value { false => SLEEPR :: NORMAL , true => SLEEPR :: SLEEP , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == SLEEPR :: NORMAL } # [ doc = "Checks if the value of the field is `SLEEP`" ] # [ inline ] pub fn is_sleep ( & self ) -> bool { * self == SLEEPR :: SLEEP } } # [ doc = "Possible values of the field `FWUP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FWUPR { # [ doc = "If SLEEP is 1 then both ADC Core and reference voltage circuitry are OFF between conversions" ] OFF , # [ doc = "If SLEEP is 1 then Fast Wake-up Sleep Mode: The Voltage reference is ON between conversions and ADC Core is OFF" ] ON } impl FWUPR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { FWUPR :: OFF => false , FWUPR :: ON => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> FWUPR { match value { false => FWUPR :: OFF , true => FWUPR :: ON , } } # [ doc = "Checks if the value of the field is `OFF`" ] # [ inline ] pub fn is_off ( & self ) -> bool { * self == FWUPR :: OFF } # [ doc = "Checks if the value of the field is `ON`" ] # [ inline ] pub fn is_on ( & self ) -> bool { * self == FWUPR :: ON } } # [ doc = "Possible values of the field `FREERUN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FREERUNR { # [ doc = "Normal Mode" ] OFF , # [ doc = "Free Run Mode: Never wait for any trigger." ] ON } impl FREERUNR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { FREERUNR :: OFF => false , FREERUNR :: ON => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> FREERUNR { match value { false => FREERUNR :: OFF , true => FREERUNR :: ON , } } # [ doc = "Checks if the value of the field is `OFF`" ] # [ inline ] pub fn is_off ( & self ) -> bool { * self == FREERUNR :: OFF } # [ doc = "Checks if the value of the field is `ON`" ] # [ inline ] pub fn is_on ( & self ) -> bool { * self == FREERUNR :: ON } } # [ doc = r" Value of the field" ] pub struct PRESCALR { bits : u8 , } impl PRESCALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `STARTUP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum STARTUPR { # [ doc = "0 periods of ADCClock" ] SUT0 , # [ doc = "8 periods of ADCClock" ] SUT8 , # [ doc = "16 periods of ADCClock" ] SUT16 , # [ doc = "24 periods of ADCClock" ] SUT24 , # [ doc = "64 periods of ADCClock" ] SUT64 , # [ doc = "80 periods of ADCClock" ] SUT80 , # [ doc = "96 periods of ADCClock" ] SUT96 , # [ doc = "112 periods of ADCClock" ] SUT112 , # [ doc = "512 periods of ADCClock" ] SUT512 , # [ doc = "576 periods of ADCClock" ] SUT576 , # [ doc = "640 periods of ADCClock" ] SUT640 , # [ doc = "704 periods of ADCClock" ] SUT704 , # [ doc = "768 periods of ADCClock" ] SUT768 , # [ doc = "832 periods of ADCClock" ] SUT832 , # [ doc = "896 periods of ADCClock" ] SUT896 , # [ doc = "960 periods of ADCClock" ] SUT960 } impl STARTUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { STARTUPR :: SUT0 => 0 , STARTUPR :: SUT8 => 0x01 , STARTUPR :: SUT16 => 0x02 , STARTUPR :: SUT24 => 0x03 , STARTUPR :: SUT64 => 0x04 , STARTUPR :: SUT80 => 0x05 , STARTUPR :: SUT96 => 0x06 , STARTUPR :: SUT112 => 0x07 , STARTUPR :: SUT512 => 0x08 , STARTUPR :: SUT576 => 0x09 , STARTUPR :: SUT640 => 0x0a , STARTUPR :: SUT704 => 0x0b , STARTUPR :: SUT768 => 0x0c , STARTUPR :: SUT832 => 0x0d , STARTUPR :: SUT896 => 0x0e , STARTUPR :: SUT960 => 0x0f } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> STARTUPR { match value { 0 => STARTUPR :: SUT0 , 1 => STARTUPR :: SUT8 , 2 => STARTUPR :: SUT16 , 3 => STARTUPR :: SUT24 , 4 => STARTUPR :: SUT64 , 5 => STARTUPR :: SUT80 , 6 => STARTUPR :: SUT96 , 7 => STARTUPR :: SUT112 , 8 => STARTUPR :: SUT512 , 9 => STARTUPR :: SUT576 , 10 => STARTUPR :: SUT640 , 11 => STARTUPR :: SUT704 , 12 => STARTUPR :: SUT768 , 13 => STARTUPR :: SUT832 , 14 => STARTUPR :: SUT896 , 15 => STARTUPR :: SUT960 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `SUT0`" ] # [ inline ] pub fn is_sut0 ( & self ) -> bool { * self == STARTUPR :: SUT0 } # [ doc = "Checks if the value of the field is `SUT8`" ] # [ inline ] pub fn is_sut8 ( & self ) -> bool { * self == STARTUPR :: SUT8 } # [ doc = "Checks if the value of the field is `SUT16`" ] # [ inline ] pub fn is_sut16 ( & self ) -> bool { * self == STARTUPR :: SUT16 } # [ doc = "Checks if the value of the field is `SUT24`" ] # [ inline ] pub fn is_sut24 ( & self ) -> bool { * self == STARTUPR :: SUT24 } # [ doc = "Checks if the value of the field is `SUT64`" ] # [ inline ] pub fn is_sut64 ( & self ) -> bool { * self == STARTUPR :: SUT64 } # [ doc = "Checks if the value of the field is `SUT80`" ] # [ inline ] pub fn is_sut80 ( & self ) -> bool { * self == STARTUPR :: SUT80 } # [ doc = "Checks if the value of the field is `SUT96`" ] # [ inline ] pub fn is_sut96 ( & self ) -> bool { * self == STARTUPR :: SUT96 } # [ doc = "Checks if the value of the field is `SUT112`" ] # [ inline ] pub fn is_sut112 ( & self ) -> bool { * self == STARTUPR :: SUT112 } # [ doc = "Checks if the value of the field is `SUT512`" ] # [ inline ] pub fn is_sut512 ( & self ) -> bool { * self == STARTUPR :: SUT512 } # [ doc = "Checks if the value of the field is `SUT576`" ] # [ inline ] pub fn is_sut576 ( & self ) -> bool { * self == STARTUPR :: SUT576 } # [ doc = "Checks if the value of the field is `SUT640`" ] # [ inline ] pub fn is_sut640 ( & self ) -> bool { * self == STARTUPR :: SUT640 } # [ doc = "Checks if the value of the field is `SUT704`" ] # [ inline ] pub fn is_sut704 ( & self ) -> bool { * self == STARTUPR :: SUT704 } # [ doc = "Checks if the value of the field is `SUT768`" ] # [ inline ] pub fn is_sut768 ( & self ) -> bool { * self == STARTUPR :: SUT768 } # [ doc = "Checks if the value of the field is `SUT832`" ] # [ inline ] pub fn is_sut832 ( & self ) -> bool { * self == STARTUPR :: SUT832 } # [ doc = "Checks if the value of the field is `SUT896`" ] # [ inline ] pub fn is_sut896 ( & self ) -> bool { * self == STARTUPR :: SUT896 } # [ doc = "Checks if the value of the field is `SUT960`" ] # [ inline ] pub fn is_sut960 ( & self ) -> bool { * self == STARTUPR :: SUT960 } } # [ doc = "Possible values of the field `SETTLING`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SETTLINGR { # [ doc = "3 periods of ADCClock" ] AST3 , # [ doc = "5 periods of ADCClock" ] AST5 , # [ doc = "9 periods of ADCClock" ] AST9 , # [ doc = "17 periods of ADCClock" ] AST17 } impl SETTLINGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SETTLINGR :: AST3 => 0 , SETTLINGR :: AST5 => 0x01 , SETTLINGR :: AST9 => 0x02 , SETTLINGR :: AST17 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SETTLINGR { match value { 0 => SETTLINGR :: AST3 , 1 => SETTLINGR :: AST5 , 2 => SETTLINGR :: AST9 , 3 => SETTLINGR :: AST17 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `AST3`" ] # [ inline ] pub fn is_ast3 ( & self ) -> bool { * self == SETTLINGR :: AST3 } # [ doc = "Checks if the value of the field is `AST5`" ] # [ inline ] pub fn is_ast5 ( & self ) -> bool { * self == SETTLINGR :: AST5 } # [ doc = "Checks if the value of the field is `AST9`" ] # [ inline ] pub fn is_ast9 ( & self ) -> bool { * self == SETTLINGR :: AST9 } # [ doc = "Checks if the value of the field is `AST17`" ] # [ inline ] pub fn is_ast17 ( & self ) -> bool { * self == SETTLINGR :: AST17 } } # [ doc = "Possible values of the field `ANACH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ANACHR { # [ doc = "No analog change on channel switching: DIFF0, GAIN0 and OFF0 are used for all channels" ] NONE , # [ doc = "Allows different analog settings for each channel. See ADC_CGR and ADC_COR Registers" ] ALLOWED } impl ANACHR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { ANACHR :: NONE => false , ANACHR :: ALLOWED => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> ANACHR { match value { false => ANACHR :: NONE , true => ANACHR :: ALLOWED , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == ANACHR :: NONE } # [ doc = "Checks if the value of the field is `ALLOWED`" ] # [ inline ] pub fn is_allowed ( & self ) -> bool { * self == ANACHR :: ALLOWED } } # [ doc = r" Value of the field" ] pub struct TRACKTIMR { bits : u8 , } impl TRACKTIMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TRANSFERR { bits : u8 , } impl TRANSFERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `USEQ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USEQR { # [ doc = "Normal Mode: The controller converts channels in a simple numeric order depending only on the channel index." ] NUM_ORDER , # [ doc = "User Sequence Mode: The sequence respects what is defined in ADC_SEQR1 and ADC_SEQR2 registers and can be used to convert several times the same channel." ] REG_ORDER } impl USEQR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { USEQR :: NUM_ORDER => false , USEQR :: REG_ORDER => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> USEQR { match value { false => USEQR :: NUM_ORDER , true => USEQR :: REG_ORDER , } } # [ doc = "Checks if the value of the field is `NUM_ORDER`" ] # [ inline ] pub fn is_num_order ( & self ) -> bool { * self == USEQR :: NUM_ORDER } # [ doc = "Checks if the value of the field is `REG_ORDER`" ] # [ inline ] pub fn is_reg_order ( & self ) -> bool { * self == USEQR :: REG_ORDER } } # [ doc = "Values that can be written to the field `TRGEN`" ] pub enum TRGENW { # [ doc = "Hardware triggers are disabled. Starting a conversion is only possible by software." ] DIS , # [ doc = "Hardware trigger selected by TRGSEL field is enabled." ] EN } impl TRGENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { TRGENW :: DIS => false , TRGENW :: EN => true } } } # [ doc = r" Proxy" ] pub struct _TRGENW < 'a > { w : & 'a mut W , } impl < 'a > _TRGENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TRGENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Hardware triggers are disabled. Starting a conversion is only possible by software." ] # [ inline ] pub fn dis ( self ) -> & 'a mut W { self . variant ( TRGENW :: DIS ) } # [ doc = "Hardware trigger selected by TRGSEL field is enabled." ] # [ inline ] pub fn en ( self ) -> & 'a mut W { self . variant ( TRGENW :: EN ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `TRGSEL`" ] pub enum TRGSELW { # [ doc = "External : ADCTRG" ] ADC_TRIG0 , # [ doc = "TIOA Output of the Timer Counter Channel 0" ] ADC_TRIG1 , # [ doc = "TIOA Output of the Timer Counter Channel 1" ] ADC_TRIG2 , # [ doc = "TIOA Output of the Timer Counter Channel 2" ] ADC_TRIG3 , # [ doc = "PWM Event Line 0" ] ADC_TRIG4 , # [ doc = "PWM Event Line 0" ] ADC_TRIG5 } impl TRGSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TRGSELW :: ADC_TRIG0 => 0 , TRGSELW :: ADC_TRIG1 => 1 , TRGSELW :: ADC_TRIG2 => 2 , TRGSELW :: ADC_TRIG3 => 3 , TRGSELW :: ADC_TRIG4 => 4 , TRGSELW :: ADC_TRIG5 => 5 } } } # [ doc = r" Proxy" ] pub struct _TRGSELW < 'a > { w : & 'a mut W , } impl < 'a > _TRGSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TRGSELW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "External : ADCTRG" ] # [ inline ] pub fn adc_trig0 ( self ) -> & 'a mut W { self . variant ( TRGSELW :: ADC_TRIG0 ) } # [ doc = "TIOA Output of the Timer Counter Channel 0" ] # [ inline ] pub fn adc_trig1 ( self ) -> & 'a mut W { self . variant ( TRGSELW :: ADC_TRIG1 ) } # [ doc = "TIOA Output of the Timer Counter Channel 1" ] # [ inline ] pub fn adc_trig2 ( self ) -> & 'a mut W { self . variant ( TRGSELW :: ADC_TRIG2 ) } # [ doc = "TIOA Output of the Timer Counter Channel 2" ] # [ inline ] pub fn adc_trig3 ( self ) -> & 'a mut W { self . variant ( TRGSELW :: ADC_TRIG3 ) } # [ doc = "PWM Event Line 0" ] # [ inline ] pub fn adc_trig4 ( self ) -> & 'a mut W { self . variant ( TRGSELW :: ADC_TRIG4 ) } # [ doc = "PWM Event Line 0" ] # [ inline ] pub fn adc_trig5 ( self ) -> & 'a mut W { self . variant ( TRGSELW :: ADC_TRIG5 ) } # [ 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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `SLEEP`" ] pub enum SLEEPW { # [ doc = "Normal Mode: The ADC Core and reference voltage circuitry are kept ON between conversions" ] NORMAL , # [ doc = "Sleep Mode: The wake-up time can be modified by programming FWUP bit" ] SLEEP } impl SLEEPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SLEEPW :: NORMAL => false , SLEEPW :: SLEEP => true } } } # [ doc = r" Proxy" ] pub struct _SLEEPW < 'a > { w : & 'a mut W , } impl < 'a > _SLEEPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SLEEPW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Normal Mode: The ADC Core and reference voltage circuitry are kept ON between conversions" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( SLEEPW :: NORMAL ) } # [ doc = "Sleep Mode: The wake-up time can be modified by programming FWUP bit" ] # [ inline ] pub fn sleep ( self ) -> & 'a mut W { self . variant ( SLEEPW :: SLEEP ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FWUP`" ] pub enum FWUPW { # [ doc = "If SLEEP is 1 then both ADC Core and reference voltage circuitry are OFF between conversions" ] OFF , # [ doc = "If SLEEP is 1 then Fast Wake-up Sleep Mode: The Voltage reference is ON between conversions and ADC Core is OFF" ] ON } impl FWUPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { FWUPW :: OFF => false , FWUPW :: ON => true } } } # [ doc = r" Proxy" ] pub struct _FWUPW < 'a > { w : & 'a mut W , } impl < 'a > _FWUPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FWUPW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "If SLEEP is 1 then both ADC Core and reference voltage circuitry are OFF between conversions" ] # [ inline ] pub fn off ( self ) -> & 'a mut W { self . variant ( FWUPW :: OFF ) } # [ doc = "If SLEEP is 1 then Fast Wake-up Sleep Mode: The Voltage reference is ON between conversions and ADC Core is OFF" ] # [ inline ] pub fn on ( self ) -> & 'a mut W { self . variant ( FWUPW :: ON ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FREERUN`" ] pub enum FREERUNW { # [ doc = "Normal Mode" ] OFF , # [ doc = "Free Run Mode: Never wait for any trigger." ] ON } impl FREERUNW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { FREERUNW :: OFF => false , FREERUNW :: ON => true } } } # [ doc = r" Proxy" ] pub struct _FREERUNW < 'a > { w : & 'a mut W , } impl < 'a > _FREERUNW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FREERUNW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Normal Mode" ] # [ inline ] pub fn off ( self ) -> & 'a mut W { self . variant ( FREERUNW :: OFF ) } # [ doc = "Free Run Mode: Never wait for any trigger." ] # [ inline ] pub fn on ( self ) -> & 'a mut W { self . variant ( FREERUNW :: ON ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PRESCALW < 'a > { w : & 'a mut W , } impl < 'a > _PRESCALW < '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 = "Values that can be written to the field `STARTUP`" ] pub enum STARTUPW { # [ doc = "0 periods of ADCClock" ] SUT0 , # [ doc = "8 periods of ADCClock" ] SUT8 , # [ doc = "16 periods of ADCClock" ] SUT16 , # [ doc = "24 periods of ADCClock" ] SUT24 , # [ doc = "64 periods of ADCClock" ] SUT64 , # [ doc = "80 periods of ADCClock" ] SUT80 , # [ doc = "96 periods of ADCClock" ] SUT96 , # [ doc = "112 periods of ADCClock" ] SUT112 , # [ doc = "512 periods of ADCClock" ] SUT512 , # [ doc = "576 periods of ADCClock" ] SUT576 , # [ doc = "640 periods of ADCClock" ] SUT640 , # [ doc = "704 periods of ADCClock" ] SUT704 , # [ doc = "768 periods of ADCClock" ] SUT768 , # [ doc = "832 periods of ADCClock" ] SUT832 , # [ doc = "896 periods of ADCClock" ] SUT896 , # [ doc = "960 periods of ADCClock" ] SUT960 } impl STARTUPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { STARTUPW :: SUT0 => 0 , STARTUPW :: SUT8 => 1 , STARTUPW :: SUT16 => 2 , STARTUPW :: SUT24 => 3 , STARTUPW :: SUT64 => 4 , STARTUPW :: SUT80 => 5 , STARTUPW :: SUT96 => 6 , STARTUPW :: SUT112 => 7 , STARTUPW :: SUT512 => 8 , STARTUPW :: SUT576 => 9 , STARTUPW :: SUT640 => 10 , STARTUPW :: SUT704 => 11 , STARTUPW :: SUT768 => 12 , STARTUPW :: SUT832 => 13 , STARTUPW :: SUT896 => 14 , STARTUPW :: SUT960 => 15 } } } # [ doc = r" Proxy" ] pub struct _STARTUPW < 'a > { w : & 'a mut W , } impl < 'a > _STARTUPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : STARTUPW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "0 periods of ADCClock" ] # [ inline ] pub fn sut0 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT0 ) } # [ doc = "8 periods of ADCClock" ] # [ inline ] pub fn sut8 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT8 ) } # [ doc = "16 periods of ADCClock" ] # [ inline ] pub fn sut16 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT16 ) } # [ doc = "24 periods of ADCClock" ] # [ inline ] pub fn sut24 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT24 ) } # [ doc = "64 periods of ADCClock" ] # [ inline ] pub fn sut64 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT64 ) } # [ doc = "80 periods of ADCClock" ] # [ inline ] pub fn sut80 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT80 ) } # [ doc = "96 periods of ADCClock" ] # [ inline ] pub fn sut96 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT96 ) } # [ doc = "112 periods of ADCClock" ] # [ inline ] pub fn sut112 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT112 ) } # [ doc = "512 periods of ADCClock" ] # [ inline ] pub fn sut512 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT512 ) } # [ doc = "576 periods of ADCClock" ] # [ inline ] pub fn sut576 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT576 ) } # [ doc = "640 periods of ADCClock" ] # [ inline ] pub fn sut640 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT640 ) } # [ doc = "704 periods of ADCClock" ] # [ inline ] pub fn sut704 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT704 ) } # [ doc = "768 periods of ADCClock" ] # [ inline ] pub fn sut768 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT768 ) } # [ doc = "832 periods of ADCClock" ] # [ inline ] pub fn sut832 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT832 ) } # [ doc = "896 periods of ADCClock" ] # [ inline ] pub fn sut896 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT896 ) } # [ doc = "960 periods of ADCClock" ] # [ inline ] pub fn sut960 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: SUT960 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SETTLING`" ] pub enum SETTLINGW { # [ doc = "3 periods of ADCClock" ] AST3 , # [ doc = "5 periods of ADCClock" ] AST5 , # [ doc = "9 periods of ADCClock" ] AST9 , # [ doc = "17 periods of ADCClock" ] AST17 } impl SETTLINGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SETTLINGW :: AST3 => 0 , SETTLINGW :: AST5 => 1 , SETTLINGW :: AST9 => 2 , SETTLINGW :: AST17 => 3 } } } # [ doc = r" Proxy" ] pub struct _SETTLINGW < 'a > { w : & 'a mut W , } impl < 'a > _SETTLINGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SETTLINGW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "3 periods of ADCClock" ] # [ inline ] pub fn ast3 ( self ) -> & 'a mut W { self . variant ( SETTLINGW :: AST3 ) } # [ doc = "5 periods of ADCClock" ] # [ inline ] pub fn ast5 ( self ) -> & 'a mut W { self . variant ( SETTLINGW :: AST5 ) } # [ doc = "9 periods of ADCClock" ] # [ inline ] pub fn ast9 ( self ) -> & 'a mut W { self . variant ( SETTLINGW :: AST9 ) } # [ doc = "17 periods of ADCClock" ] # [ inline ] pub fn ast17 ( self ) -> & 'a mut W { self . variant ( SETTLINGW :: AST17 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `ANACH`" ] pub enum ANACHW { # [ doc = "No analog change on channel switching: DIFF0, GAIN0 and OFF0 are used for all channels" ] NONE , # [ doc = "Allows different analog settings for each channel. See ADC_CGR and ADC_COR Registers" ] ALLOWED } impl ANACHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { ANACHW :: NONE => false , ANACHW :: ALLOWED => true } } } # [ doc = r" Proxy" ] pub struct _ANACHW < 'a > { w : & 'a mut W , } impl < 'a > _ANACHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ANACHW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "No analog change on channel switching: DIFF0, GAIN0 and OFF0 are used for all channels" ] # [ inline ] pub fn none ( self ) -> & 'a mut W { self . variant ( ANACHW :: NONE ) } # [ doc = "Allows different analog settings for each channel. See ADC_CGR and ADC_COR Registers" ] # [ inline ] pub fn allowed ( self ) -> & 'a mut W { self . variant ( ANACHW :: ALLOWED ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRACKTIMW < 'a > { w : & 'a mut W , } impl < 'a > _TRACKTIMW < '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 _TRANSFERW < 'a > { w : & 'a mut W , } impl < 'a > _TRANSFERW < '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 = "Values that can be written to the field `USEQ`" ] pub enum USEQW { # [ doc = "Normal Mode: The controller converts channels in a simple numeric order depending only on the channel index." ] NUM_ORDER , # [ doc = "User Sequence Mode: The sequence respects what is defined in ADC_SEQR1 and ADC_SEQR2 registers and can be used to convert several times the same channel." ] REG_ORDER } impl USEQW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { USEQW :: NUM_ORDER => false , USEQW :: REG_ORDER => true } } } # [ doc = r" Proxy" ] pub struct _USEQW < 'a > { w : & 'a mut W , } impl < 'a > _USEQW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USEQW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Normal Mode: The controller converts channels in a simple numeric order depending only on the channel index." ] # [ inline ] pub fn num_order ( self ) -> & 'a mut W { self . variant ( USEQW :: NUM_ORDER ) } # [ doc = "User Sequence Mode: The sequence respects what is defined in ADC_SEQR1 and ADC_SEQR2 registers and can be used to convert several times the same channel." ] # [ inline ] pub fn reg_order ( self ) -> & 'a mut W { self . variant ( USEQW :: REG_ORDER ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Trigger Enable" ] # [ inline ] pub fn trgen ( & self ) -> TRGENR { TRGENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 1:3 - Trigger Selection" ] # [ inline ] pub fn trgsel ( & self ) -> TRGSELR { TRGSELR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 5 - Sleep Mode" ] # [ inline ] pub fn sleep ( & self ) -> SLEEPR { SLEEPR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 6 - Fast Wake Up" ] # [ inline ] pub fn fwup ( & self ) -> FWUPR { FWUPR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 7 - Free Run Mode" ] # [ inline ] pub fn freerun ( & self ) -> FREERUNR { FREERUNR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 8:15 - Prescaler Rate Selection" ] # [ inline ] pub fn prescal ( & self ) -> PRESCALR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PRESCALR { bits } } # [ doc = "Bits 16:19 - Start Up Time" ] # [ inline ] pub fn startup ( & self ) -> STARTUPR { STARTUPR :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:21 - Analog Settling Time" ] # [ inline ] pub fn settling ( & self ) -> SETTLINGR { SETTLINGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 23 - Analog Change" ] # [ inline ] pub fn anach ( & self ) -> ANACHR { ANACHR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:27 - Tracking Time" ] # [ inline ] pub fn tracktim ( & self ) -> TRACKTIMR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRACKTIMR { bits } } # [ doc = "Bits 28:29 - Transfer Period" ] # [ inline ] pub fn transfer ( & self ) -> TRANSFERR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRANSFERR { bits } } # [ doc = "Bit 31 - Use Sequence Enable" ] # [ inline ] pub fn useq ( & self ) -> USEQR { USEQR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } 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 - Trigger Enable" ] # [ inline ] pub fn trgen ( & mut self ) -> _TRGENW { _TRGENW { w : self } } # [ doc = "Bits 1:3 - Trigger Selection" ] # [ inline ] pub fn trgsel ( & mut self ) -> _TRGSELW { _TRGSELW { w : self } } # [ doc = "Bit 5 - Sleep Mode" ] # [ inline ] pub fn sleep ( & mut self ) -> _SLEEPW { _SLEEPW { w : self } } # [ doc = "Bit 6 - Fast Wake Up" ] # [ inline ] pub fn fwup ( & mut self ) -> _FWUPW { _FWUPW { w : self } } # [ doc = "Bit 7 - Free Run Mode" ] # [ inline ] pub fn freerun ( & mut self ) -> _FREERUNW { _FREERUNW { w : self } } # [ doc = "Bits 8:15 - Prescaler Rate Selection" ] # [ inline ] pub fn prescal ( & mut self ) -> _PRESCALW { _PRESCALW { w : self } } # [ doc = "Bits 16:19 - Start Up Time" ] # [ inline ] pub fn startup ( & mut self ) -> _STARTUPW { _STARTUPW { w : self } } # [ doc = "Bits 20:21 - Analog Settling Time" ] # [ inline ] pub fn settling ( & mut self ) -> _SETTLINGW { _SETTLINGW { w : self } } # [ doc = "Bit 23 - Analog Change" ] # [ inline ] pub fn anach ( & mut self ) -> _ANACHW { _ANACHW { w : self } } # [ doc = "Bits 24:27 - Tracking Time" ] # [ inline ] pub fn tracktim ( & mut self ) -> _TRACKTIMW { _TRACKTIMW { w : self } } # [ doc = "Bits 28:29 - Transfer Period" ] # [ inline ] pub fn transfer ( & mut self ) -> _TRANSFERW { _TRANSFERW { w : self } } # [ doc = "Bit 31 - Use Sequence Enable" ] # [ inline ] pub fn useq ( & mut self ) -> _USEQW { _USEQW { w : self } } } } # [ doc = "Channel Sequence Register 1" ] pub struct SEQR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Sequence Register 1" ] pub mod seqr1 { # [ 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 :: SEQR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 USCH1R { bits : u8 , } impl USCH1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH2R { bits : u8 , } impl USCH2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH3R { bits : u8 , } impl USCH3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH4R { bits : u8 , } impl USCH4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH5R { bits : u8 , } impl USCH5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH6R { bits : u8 , } impl USCH6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH7R { bits : u8 , } impl USCH7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH8R { bits : u8 , } impl USCH8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _USCH1W < 'a > { w : & 'a mut W , } impl < 'a > _USCH1W < '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 } } # [ doc = r" Proxy" ] pub struct _USCH2W < 'a > { w : & 'a mut W , } impl < 'a > _USCH2W < '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 _USCH3W < 'a > { w : & 'a mut W , } impl < 'a > _USCH3W < '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 _USCH4W < 'a > { w : & 'a mut W , } impl < 'a > _USCH4W < '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 _USCH5W < 'a > { w : & 'a mut W , } impl < 'a > _USCH5W < '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 _USCH6W < 'a > { w : & 'a mut W , } impl < 'a > _USCH6W < '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 _USCH7W < 'a > { w : & 'a mut W , } impl < 'a > _USCH7W < '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 _USCH8W < 'a > { w : & 'a mut W , } impl < 'a > _USCH8W < '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:3 - User Sequence Number 1" ] # [ inline ] pub fn usch1 ( & self ) -> USCH1R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH1R { bits } } # [ doc = "Bits 4:7 - User Sequence Number 2" ] # [ inline ] pub fn usch2 ( & self ) -> USCH2R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH2R { bits } } # [ doc = "Bits 8:11 - User Sequence Number 3" ] # [ inline ] pub fn usch3 ( & self ) -> USCH3R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH3R { bits } } # [ doc = "Bits 12:15 - User Sequence Number 4" ] # [ inline ] pub fn usch4 ( & self ) -> USCH4R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH4R { bits } } # [ doc = "Bits 16:19 - User Sequence Number 5" ] # [ inline ] pub fn usch5 ( & self ) -> USCH5R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH5R { bits } } # [ doc = "Bits 20:23 - User Sequence Number 6" ] # [ inline ] pub fn usch6 ( & self ) -> USCH6R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH6R { bits } } # [ doc = "Bits 24:27 - User Sequence Number 7" ] # [ inline ] pub fn usch7 ( & self ) -> USCH7R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH7R { bits } } # [ doc = "Bits 28:31 - User Sequence Number 8" ] # [ inline ] pub fn usch8 ( & self ) -> USCH8R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH8R { 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 - User Sequence Number 1" ] # [ inline ] pub fn usch1 ( & mut self ) -> _USCH1W { _USCH1W { w : self } } # [ doc = "Bits 4:7 - User Sequence Number 2" ] # [ inline ] pub fn usch2 ( & mut self ) -> _USCH2W { _USCH2W { w : self } } # [ doc = "Bits 8:11 - User Sequence Number 3" ] # [ inline ] pub fn usch3 ( & mut self ) -> _USCH3W { _USCH3W { w : self } } # [ doc = "Bits 12:15 - User Sequence Number 4" ] # [ inline ] pub fn usch4 ( & mut self ) -> _USCH4W { _USCH4W { w : self } } # [ doc = "Bits 16:19 - User Sequence Number 5" ] # [ inline ] pub fn usch5 ( & mut self ) -> _USCH5W { _USCH5W { w : self } } # [ doc = "Bits 20:23 - User Sequence Number 6" ] # [ inline ] pub fn usch6 ( & mut self ) -> _USCH6W { _USCH6W { w : self } } # [ doc = "Bits 24:27 - User Sequence Number 7" ] # [ inline ] pub fn usch7 ( & mut self ) -> _USCH7W { _USCH7W { w : self } } # [ doc = "Bits 28:31 - User Sequence Number 8" ] # [ inline ] pub fn usch8 ( & mut self ) -> _USCH8W { _USCH8W { w : self } } } } # [ doc = "Channel Sequence Register 2" ] pub struct SEQR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Sequence Register 2" ] pub mod seqr2 { # [ 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 :: SEQR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 USCH9R { bits : u8 , } impl USCH9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH10R { bits : u8 , } impl USCH10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH11R { bits : u8 , } impl USCH11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH12R { bits : u8 , } impl USCH12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH13R { bits : u8 , } impl USCH13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH14R { bits : u8 , } impl USCH14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct USCH15R { bits : u8 , } impl USCH15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _USCH9W < 'a > { w : & 'a mut W , } impl < 'a > _USCH9W < '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 } } # [ doc = r" Proxy" ] pub struct _USCH10W < 'a > { w : & 'a mut W , } impl < 'a > _USCH10W < '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 _USCH11W < 'a > { w : & 'a mut W , } impl < 'a > _USCH11W < '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 _USCH12W < 'a > { w : & 'a mut W , } impl < 'a > _USCH12W < '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 _USCH13W < 'a > { w : & 'a mut W , } impl < 'a > _USCH13W < '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 _USCH14W < 'a > { w : & 'a mut W , } impl < 'a > _USCH14W < '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 _USCH15W < 'a > { w : & 'a mut W , } impl < 'a > _USCH15W < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - User Sequence Number 9" ] # [ inline ] pub fn usch9 ( & self ) -> USCH9R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH9R { bits } } # [ doc = "Bits 4:7 - User Sequence Number 10" ] # [ inline ] pub fn usch10 ( & self ) -> USCH10R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH10R { bits } } # [ doc = "Bits 8:11 - User Sequence Number 11" ] # [ inline ] pub fn usch11 ( & self ) -> USCH11R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH11R { bits } } # [ doc = "Bits 12:15 - User Sequence Number 12" ] # [ inline ] pub fn usch12 ( & self ) -> USCH12R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH12R { bits } } # [ doc = "Bits 16:19 - User Sequence Number 13" ] # [ inline ] pub fn usch13 ( & self ) -> USCH13R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH13R { bits } } # [ doc = "Bits 20:23 - User Sequence Number 14" ] # [ inline ] pub fn usch14 ( & self ) -> USCH14R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH14R { bits } } # [ doc = "Bits 24:27 - User Sequence Number 15" ] # [ inline ] pub fn usch15 ( & self ) -> USCH15R { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USCH15R { 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 - User Sequence Number 9" ] # [ inline ] pub fn usch9 ( & mut self ) -> _USCH9W { _USCH9W { w : self } } # [ doc = "Bits 4:7 - User Sequence Number 10" ] # [ inline ] pub fn usch10 ( & mut self ) -> _USCH10W { _USCH10W { w : self } } # [ doc = "Bits 8:11 - User Sequence Number 11" ] # [ inline ] pub fn usch11 ( & mut self ) -> _USCH11W { _USCH11W { w : self } } # [ doc = "Bits 12:15 - User Sequence Number 12" ] # [ inline ] pub fn usch12 ( & mut self ) -> _USCH12W { _USCH12W { w : self } } # [ doc = "Bits 16:19 - User Sequence Number 13" ] # [ inline ] pub fn usch13 ( & mut self ) -> _USCH13W { _USCH13W { w : self } } # [ doc = "Bits 20:23 - User Sequence Number 14" ] # [ inline ] pub fn usch14 ( & mut self ) -> _USCH14W { _USCH14W { w : self } } # [ doc = "Bits 24:27 - User Sequence Number 15" ] # [ inline ] pub fn usch15 ( & mut self ) -> _USCH15W { _USCH15W { w : self } } } } # [ doc = "Channel Enable Register" ] pub struct CHER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Enable Register" ] pub mod cher { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CHER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CH0W < 'a > { w : & 'a mut W , } impl < 'a > _CH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH1W < 'a > { w : & 'a mut W , } impl < 'a > _CH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH2W < 'a > { w : & 'a mut W , } impl < 'a > _CH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH3W < 'a > { w : & 'a mut W , } impl < 'a > _CH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH4W < 'a > { w : & 'a mut W , } impl < 'a > _CH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH5W < 'a > { w : & 'a mut W , } impl < 'a > _CH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH6W < 'a > { w : & 'a mut W , } impl < 'a > _CH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH7W < 'a > { w : & 'a mut W , } impl < 'a > _CH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH8W < 'a > { w : & 'a mut W , } impl < 'a > _CH8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH9W < 'a > { w : & 'a mut W , } impl < 'a > _CH9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH10W < 'a > { w : & 'a mut W , } impl < 'a > _CH10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH11W < 'a > { w : & 'a mut W , } impl < 'a > _CH11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH12W < 'a > { w : & 'a mut W , } impl < 'a > _CH12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH13W < 'a > { w : & 'a mut W , } impl < 'a > _CH13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH14W < 'a > { w : & 'a mut W , } impl < 'a > _CH14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH15W < 'a > { w : & 'a mut W , } impl < 'a > _CH15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Channel 0 Enable" ] # [ inline ] pub fn ch0 ( & mut self ) -> _CH0W { _CH0W { w : self } } # [ doc = "Bit 1 - Channel 1 Enable" ] # [ inline ] pub fn ch1 ( & mut self ) -> _CH1W { _CH1W { w : self } } # [ doc = "Bit 2 - Channel 2 Enable" ] # [ inline ] pub fn ch2 ( & mut self ) -> _CH2W { _CH2W { w : self } } # [ doc = "Bit 3 - Channel 3 Enable" ] # [ inline ] pub fn ch3 ( & mut self ) -> _CH3W { _CH3W { w : self } } # [ doc = "Bit 4 - Channel 4 Enable" ] # [ inline ] pub fn ch4 ( & mut self ) -> _CH4W { _CH4W { w : self } } # [ doc = "Bit 5 - Channel 5 Enable" ] # [ inline ] pub fn ch5 ( & mut self ) -> _CH5W { _CH5W { w : self } } # [ doc = "Bit 6 - Channel 6 Enable" ] # [ inline ] pub fn ch6 ( & mut self ) -> _CH6W { _CH6W { w : self } } # [ doc = "Bit 7 - Channel 7 Enable" ] # [ inline ] pub fn ch7 ( & mut self ) -> _CH7W { _CH7W { w : self } } # [ doc = "Bit 8 - Channel 8 Enable" ] # [ inline ] pub fn ch8 ( & mut self ) -> _CH8W { _CH8W { w : self } } # [ doc = "Bit 9 - Channel 9 Enable" ] # [ inline ] pub fn ch9 ( & mut self ) -> _CH9W { _CH9W { w : self } } # [ doc = "Bit 10 - Channel 10 Enable" ] # [ inline ] pub fn ch10 ( & mut self ) -> _CH10W { _CH10W { w : self } } # [ doc = "Bit 11 - Channel 11 Enable" ] # [ inline ] pub fn ch11 ( & mut self ) -> _CH11W { _CH11W { w : self } } # [ doc = "Bit 12 - Channel 12 Enable" ] # [ inline ] pub fn ch12 ( & mut self ) -> _CH12W { _CH12W { w : self } } # [ doc = "Bit 13 - Channel 13 Enable" ] # [ inline ] pub fn ch13 ( & mut self ) -> _CH13W { _CH13W { w : self } } # [ doc = "Bit 14 - Channel 14 Enable" ] # [ inline ] pub fn ch14 ( & mut self ) -> _CH14W { _CH14W { w : self } } # [ doc = "Bit 15 - Channel 15 Enable" ] # [ inline ] pub fn ch15 ( & mut self ) -> _CH15W { _CH15W { w : self } } } } # [ doc = "Channel Disable Register" ] pub struct CHDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Disable Register" ] pub mod chdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CHDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CH0W < 'a > { w : & 'a mut W , } impl < 'a > _CH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH1W < 'a > { w : & 'a mut W , } impl < 'a > _CH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH2W < 'a > { w : & 'a mut W , } impl < 'a > _CH2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH3W < 'a > { w : & 'a mut W , } impl < 'a > _CH3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH4W < 'a > { w : & 'a mut W , } impl < 'a > _CH4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH5W < 'a > { w : & 'a mut W , } impl < 'a > _CH5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH6W < 'a > { w : & 'a mut W , } impl < 'a > _CH6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH7W < 'a > { w : & 'a mut W , } impl < 'a > _CH7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH8W < 'a > { w : & 'a mut W , } impl < 'a > _CH8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH9W < 'a > { w : & 'a mut W , } impl < 'a > _CH9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH10W < 'a > { w : & 'a mut W , } impl < 'a > _CH10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH11W < 'a > { w : & 'a mut W , } impl < 'a > _CH11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH12W < 'a > { w : & 'a mut W , } impl < 'a > _CH12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH13W < 'a > { w : & 'a mut W , } impl < 'a > _CH13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH14W < 'a > { w : & 'a mut W , } impl < 'a > _CH14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH15W < 'a > { w : & 'a mut W , } impl < 'a > _CH15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Channel 0 Disable" ] # [ inline ] pub fn ch0 ( & mut self ) -> _CH0W { _CH0W { w : self } } # [ doc = "Bit 1 - Channel 1 Disable" ] # [ inline ] pub fn ch1 ( & mut self ) -> _CH1W { _CH1W { w : self } } # [ doc = "Bit 2 - Channel 2 Disable" ] # [ inline ] pub fn ch2 ( & mut self ) -> _CH2W { _CH2W { w : self } } # [ doc = "Bit 3 - Channel 3 Disable" ] # [ inline ] pub fn ch3 ( & mut self ) -> _CH3W { _CH3W { w : self } } # [ doc = "Bit 4 - Channel 4 Disable" ] # [ inline ] pub fn ch4 ( & mut self ) -> _CH4W { _CH4W { w : self } } # [ doc = "Bit 5 - Channel 5 Disable" ] # [ inline ] pub fn ch5 ( & mut self ) -> _CH5W { _CH5W { w : self } } # [ doc = "Bit 6 - Channel 6 Disable" ] # [ inline ] pub fn ch6 ( & mut self ) -> _CH6W { _CH6W { w : self } } # [ doc = "Bit 7 - Channel 7 Disable" ] # [ inline ] pub fn ch7 ( & mut self ) -> _CH7W { _CH7W { w : self } } # [ doc = "Bit 8 - Channel 8 Disable" ] # [ inline ] pub fn ch8 ( & mut self ) -> _CH8W { _CH8W { w : self } } # [ doc = "Bit 9 - Channel 9 Disable" ] # [ inline ] pub fn ch9 ( & mut self ) -> _CH9W { _CH9W { w : self } } # [ doc = "Bit 10 - Channel 10 Disable" ] # [ inline ] pub fn ch10 ( & mut self ) -> _CH10W { _CH10W { w : self } } # [ doc = "Bit 11 - Channel 11 Disable" ] # [ inline ] pub fn ch11 ( & mut self ) -> _CH11W { _CH11W { w : self } } # [ doc = "Bit 12 - Channel 12 Disable" ] # [ inline ] pub fn ch12 ( & mut self ) -> _CH12W { _CH12W { w : self } } # [ doc = "Bit 13 - Channel 13 Disable" ] # [ inline ] pub fn ch13 ( & mut self ) -> _CH13W { _CH13W { w : self } } # [ doc = "Bit 14 - Channel 14 Disable" ] # [ inline ] pub fn ch14 ( & mut self ) -> _CH14W { _CH14W { w : self } } # [ doc = "Bit 15 - Channel 15 Disable" ] # [ inline ] pub fn ch15 ( & mut self ) -> _CH15W { _CH15W { w : self } } } } # [ doc = "Channel Status Register" ] pub struct CHSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod chsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CHSR { # [ 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 CH0R { bits : bool , } impl CH0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH1R { bits : bool , } impl CH1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH2R { bits : bool , } impl CH2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH3R { bits : bool , } impl CH3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH4R { bits : bool , } impl CH4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH5R { bits : bool , } impl CH5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH6R { bits : bool , } impl CH6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH7R { bits : bool , } impl CH7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH8R { bits : bool , } impl CH8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH9R { bits : bool , } impl CH9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH10R { bits : bool , } impl CH10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH11R { bits : bool , } impl CH11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH12R { bits : bool , } impl CH12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH13R { bits : bool , } impl CH13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH14R { bits : bool , } impl CH14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH15R { bits : bool , } impl CH15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0 Status" ] # [ inline ] pub fn ch0 ( & self ) -> CH0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH0R { bits } } # [ doc = "Bit 1 - Channel 1 Status" ] # [ inline ] pub fn ch1 ( & self ) -> CH1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH1R { bits } } # [ doc = "Bit 2 - Channel 2 Status" ] # [ inline ] pub fn ch2 ( & self ) -> CH2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH2R { bits } } # [ doc = "Bit 3 - Channel 3 Status" ] # [ inline ] pub fn ch3 ( & self ) -> CH3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH3R { bits } } # [ doc = "Bit 4 - Channel 4 Status" ] # [ inline ] pub fn ch4 ( & self ) -> CH4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH4R { bits } } # [ doc = "Bit 5 - Channel 5 Status" ] # [ inline ] pub fn ch5 ( & self ) -> CH5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH5R { bits } } # [ doc = "Bit 6 - Channel 6 Status" ] # [ inline ] pub fn ch6 ( & self ) -> CH6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH6R { bits } } # [ doc = "Bit 7 - Channel 7 Status" ] # [ inline ] pub fn ch7 ( & self ) -> CH7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH7R { bits } } # [ doc = "Bit 8 - Channel 8 Status" ] # [ inline ] pub fn ch8 ( & self ) -> CH8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH8R { bits } } # [ doc = "Bit 9 - Channel 9 Status" ] # [ inline ] pub fn ch9 ( & self ) -> CH9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH9R { bits } } # [ doc = "Bit 10 - Channel 10 Status" ] # [ inline ] pub fn ch10 ( & self ) -> CH10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH10R { bits } } # [ doc = "Bit 11 - Channel 11 Status" ] # [ inline ] pub fn ch11 ( & self ) -> CH11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH11R { bits } } # [ doc = "Bit 12 - Channel 12 Status" ] # [ inline ] pub fn ch12 ( & self ) -> CH12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH12R { bits } } # [ doc = "Bit 13 - Channel 13 Status" ] # [ inline ] pub fn ch13 ( & self ) -> CH13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH13R { bits } } # [ doc = "Bit 14 - Channel 14 Status" ] # [ inline ] pub fn ch14 ( & self ) -> CH14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH14R { bits } } # [ doc = "Bit 15 - Channel 15 Status" ] # [ inline ] pub fn ch15 ( & self ) -> CH15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH15R { bits } } } } # [ doc = "Last Converted Data Register" ] pub struct LCDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Last Converted Data Register" ] pub mod lcdr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LCDR { # [ 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 LDATAR { bits : u16 , } impl LDATAR { # [ 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 CHNBR { bits : u8 , } impl CHNBR { # [ 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:11 - Last Data Converted" ] # [ inline ] pub fn ldata ( & self ) -> LDATAR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; LDATAR { bits } } # [ doc = "Bits 12:15 - Channel Number" ] # [ inline ] pub fn chnb ( & self ) -> CHNBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CHNBR { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _EOC0W < 'a > { w : & 'a mut W , } impl < 'a > _EOC0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC1W < 'a > { w : & 'a mut W , } impl < 'a > _EOC1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC2W < 'a > { w : & 'a mut W , } impl < 'a > _EOC2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC3W < 'a > { w : & 'a mut W , } impl < 'a > _EOC3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC4W < 'a > { w : & 'a mut W , } impl < 'a > _EOC4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC5W < 'a > { w : & 'a mut W , } impl < 'a > _EOC5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC6W < 'a > { w : & 'a mut W , } impl < 'a > _EOC6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC7W < 'a > { w : & 'a mut W , } impl < 'a > _EOC7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC8W < 'a > { w : & 'a mut W , } impl < 'a > _EOC8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC9W < 'a > { w : & 'a mut W , } impl < 'a > _EOC9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC10W < 'a > { w : & 'a mut W , } impl < 'a > _EOC10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC11W < 'a > { w : & 'a mut W , } impl < 'a > _EOC11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC12W < 'a > { w : & 'a mut W , } impl < 'a > _EOC12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC13W < 'a > { w : & 'a mut W , } impl < 'a > _EOC13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC14W < 'a > { w : & 'a mut W , } impl < 'a > _EOC14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC15W < 'a > { w : & 'a mut W , } impl < 'a > _EOC15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRDYW < 'a > { w : & 'a mut W , } impl < 'a > _DRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GOVREW < 'a > { w : & 'a mut W , } impl < 'a > _GOVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _COMPEW < 'a > { w : & 'a mut W , } impl < 'a > _COMPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - End of Conversion Interrupt Enable 0" ] # [ inline ] pub fn eoc0 ( & mut self ) -> _EOC0W { _EOC0W { w : self } } # [ doc = "Bit 1 - End of Conversion Interrupt Enable 1" ] # [ inline ] pub fn eoc1 ( & mut self ) -> _EOC1W { _EOC1W { w : self } } # [ doc = "Bit 2 - End of Conversion Interrupt Enable 2" ] # [ inline ] pub fn eoc2 ( & mut self ) -> _EOC2W { _EOC2W { w : self } } # [ doc = "Bit 3 - End of Conversion Interrupt Enable 3" ] # [ inline ] pub fn eoc3 ( & mut self ) -> _EOC3W { _EOC3W { w : self } } # [ doc = "Bit 4 - End of Conversion Interrupt Enable 4" ] # [ inline ] pub fn eoc4 ( & mut self ) -> _EOC4W { _EOC4W { w : self } } # [ doc = "Bit 5 - End of Conversion Interrupt Enable 5" ] # [ inline ] pub fn eoc5 ( & mut self ) -> _EOC5W { _EOC5W { w : self } } # [ doc = "Bit 6 - End of Conversion Interrupt Enable 6" ] # [ inline ] pub fn eoc6 ( & mut self ) -> _EOC6W { _EOC6W { w : self } } # [ doc = "Bit 7 - End of Conversion Interrupt Enable 7" ] # [ inline ] pub fn eoc7 ( & mut self ) -> _EOC7W { _EOC7W { w : self } } # [ doc = "Bit 8 - End of Conversion Interrupt Enable 8" ] # [ inline ] pub fn eoc8 ( & mut self ) -> _EOC8W { _EOC8W { w : self } } # [ doc = "Bit 9 - End of Conversion Interrupt Enable 9" ] # [ inline ] pub fn eoc9 ( & mut self ) -> _EOC9W { _EOC9W { w : self } } # [ doc = "Bit 10 - End of Conversion Interrupt Enable 10" ] # [ inline ] pub fn eoc10 ( & mut self ) -> _EOC10W { _EOC10W { w : self } } # [ doc = "Bit 11 - End of Conversion Interrupt Enable 11" ] # [ inline ] pub fn eoc11 ( & mut self ) -> _EOC11W { _EOC11W { w : self } } # [ doc = "Bit 12 - End of Conversion Interrupt Enable 12" ] # [ inline ] pub fn eoc12 ( & mut self ) -> _EOC12W { _EOC12W { w : self } } # [ doc = "Bit 13 - End of Conversion Interrupt Enable 13" ] # [ inline ] pub fn eoc13 ( & mut self ) -> _EOC13W { _EOC13W { w : self } } # [ doc = "Bit 14 - End of Conversion Interrupt Enable 14" ] # [ inline ] pub fn eoc14 ( & mut self ) -> _EOC14W { _EOC14W { w : self } } # [ doc = "Bit 15 - End of Conversion Interrupt Enable 15" ] # [ inline ] pub fn eoc15 ( & mut self ) -> _EOC15W { _EOC15W { w : self } } # [ doc = "Bit 24 - Data Ready Interrupt Enable" ] # [ inline ] pub fn drdy ( & mut self ) -> _DRDYW { _DRDYW { w : self } } # [ doc = "Bit 25 - General Overrun Error Interrupt Enable" ] # [ inline ] pub fn govre ( & mut self ) -> _GOVREW { _GOVREW { w : self } } # [ doc = "Bit 26 - Comparison Event Interrupt Enable" ] # [ inline ] pub fn compe ( & mut self ) -> _COMPEW { _COMPEW { w : self } } # [ doc = "Bit 27 - End of Receive Buffer Interrupt Enable" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 28 - Receive Buffer Full Interrupt Enable" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _EOC0W < 'a > { w : & 'a mut W , } impl < 'a > _EOC0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC1W < 'a > { w : & 'a mut W , } impl < 'a > _EOC1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC2W < 'a > { w : & 'a mut W , } impl < 'a > _EOC2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC3W < 'a > { w : & 'a mut W , } impl < 'a > _EOC3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC4W < 'a > { w : & 'a mut W , } impl < 'a > _EOC4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC5W < 'a > { w : & 'a mut W , } impl < 'a > _EOC5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC6W < 'a > { w : & 'a mut W , } impl < 'a > _EOC6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC7W < 'a > { w : & 'a mut W , } impl < 'a > _EOC7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC8W < 'a > { w : & 'a mut W , } impl < 'a > _EOC8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC9W < 'a > { w : & 'a mut W , } impl < 'a > _EOC9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC10W < 'a > { w : & 'a mut W , } impl < 'a > _EOC10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC11W < 'a > { w : & 'a mut W , } impl < 'a > _EOC11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC12W < 'a > { w : & 'a mut W , } impl < 'a > _EOC12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC13W < 'a > { w : & 'a mut W , } impl < 'a > _EOC13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC14W < 'a > { w : & 'a mut W , } impl < 'a > _EOC14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EOC15W < 'a > { w : & 'a mut W , } impl < 'a > _EOC15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DRDYW < 'a > { w : & 'a mut W , } impl < 'a > _DRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _GOVREW < 'a > { w : & 'a mut W , } impl < 'a > _GOVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _COMPEW < 'a > { w : & 'a mut W , } impl < 'a > _COMPEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - End of Conversion Interrupt Disable 0" ] # [ inline ] pub fn eoc0 ( & mut self ) -> _EOC0W { _EOC0W { w : self } } # [ doc = "Bit 1 - End of Conversion Interrupt Disable 1" ] # [ inline ] pub fn eoc1 ( & mut self ) -> _EOC1W { _EOC1W { w : self } } # [ doc = "Bit 2 - End of Conversion Interrupt Disable 2" ] # [ inline ] pub fn eoc2 ( & mut self ) -> _EOC2W { _EOC2W { w : self } } # [ doc = "Bit 3 - End of Conversion Interrupt Disable 3" ] # [ inline ] pub fn eoc3 ( & mut self ) -> _EOC3W { _EOC3W { w : self } } # [ doc = "Bit 4 - End of Conversion Interrupt Disable 4" ] # [ inline ] pub fn eoc4 ( & mut self ) -> _EOC4W { _EOC4W { w : self } } # [ doc = "Bit 5 - End of Conversion Interrupt Disable 5" ] # [ inline ] pub fn eoc5 ( & mut self ) -> _EOC5W { _EOC5W { w : self } } # [ doc = "Bit 6 - End of Conversion Interrupt Disable 6" ] # [ inline ] pub fn eoc6 ( & mut self ) -> _EOC6W { _EOC6W { w : self } } # [ doc = "Bit 7 - End of Conversion Interrupt Disable 7" ] # [ inline ] pub fn eoc7 ( & mut self ) -> _EOC7W { _EOC7W { w : self } } # [ doc = "Bit 8 - End of Conversion Interrupt Disable 8" ] # [ inline ] pub fn eoc8 ( & mut self ) -> _EOC8W { _EOC8W { w : self } } # [ doc = "Bit 9 - End of Conversion Interrupt Disable 9" ] # [ inline ] pub fn eoc9 ( & mut self ) -> _EOC9W { _EOC9W { w : self } } # [ doc = "Bit 10 - End of Conversion Interrupt Disable 10" ] # [ inline ] pub fn eoc10 ( & mut self ) -> _EOC10W { _EOC10W { w : self } } # [ doc = "Bit 11 - End of Conversion Interrupt Disable 11" ] # [ inline ] pub fn eoc11 ( & mut self ) -> _EOC11W { _EOC11W { w : self } } # [ doc = "Bit 12 - End of Conversion Interrupt Disable 12" ] # [ inline ] pub fn eoc12 ( & mut self ) -> _EOC12W { _EOC12W { w : self } } # [ doc = "Bit 13 - End of Conversion Interrupt Disable 13" ] # [ inline ] pub fn eoc13 ( & mut self ) -> _EOC13W { _EOC13W { w : self } } # [ doc = "Bit 14 - End of Conversion Interrupt Disable 14" ] # [ inline ] pub fn eoc14 ( & mut self ) -> _EOC14W { _EOC14W { w : self } } # [ doc = "Bit 15 - End of Conversion Interrupt Disable 15" ] # [ inline ] pub fn eoc15 ( & mut self ) -> _EOC15W { _EOC15W { w : self } } # [ doc = "Bit 24 - Data Ready Interrupt Disable" ] # [ inline ] pub fn drdy ( & mut self ) -> _DRDYW { _DRDYW { w : self } } # [ doc = "Bit 25 - General Overrun Error Interrupt Disable" ] # [ inline ] pub fn govre ( & mut self ) -> _GOVREW { _GOVREW { w : self } } # [ doc = "Bit 26 - Comparison Event Interrupt Disable" ] # [ inline ] pub fn compe ( & mut self ) -> _COMPEW { _COMPEW { w : self } } # [ doc = "Bit 27 - End of Receive Buffer Interrupt Disable" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 28 - Receive Buffer Full Interrupt Disable" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 EOC0R { bits : bool , } impl EOC0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC1R { bits : bool , } impl EOC1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC2R { bits : bool , } impl EOC2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC3R { bits : bool , } impl EOC3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC4R { bits : bool , } impl EOC4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC5R { bits : bool , } impl EOC5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC6R { bits : bool , } impl EOC6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC7R { bits : bool , } impl EOC7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC8R { bits : bool , } impl EOC8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC9R { bits : bool , } impl EOC9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC10R { bits : bool , } impl EOC10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC11R { bits : bool , } impl EOC11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC12R { bits : bool , } impl EOC12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC13R { bits : bool , } impl EOC13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC14R { bits : bool , } impl EOC14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC15R { bits : bool , } impl EOC15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRDYR { bits : bool , } impl DRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GOVRER { bits : bool , } impl GOVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct COMPER { bits : bool , } impl COMPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - End of Conversion Interrupt Mask 0" ] # [ inline ] pub fn eoc0 ( & self ) -> EOC0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC0R { bits } } # [ doc = "Bit 1 - End of Conversion Interrupt Mask 1" ] # [ inline ] pub fn eoc1 ( & self ) -> EOC1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC1R { bits } } # [ doc = "Bit 2 - End of Conversion Interrupt Mask 2" ] # [ inline ] pub fn eoc2 ( & self ) -> EOC2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC2R { bits } } # [ doc = "Bit 3 - End of Conversion Interrupt Mask 3" ] # [ inline ] pub fn eoc3 ( & self ) -> EOC3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC3R { bits } } # [ doc = "Bit 4 - End of Conversion Interrupt Mask 4" ] # [ inline ] pub fn eoc4 ( & self ) -> EOC4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC4R { bits } } # [ doc = "Bit 5 - End of Conversion Interrupt Mask 5" ] # [ inline ] pub fn eoc5 ( & self ) -> EOC5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC5R { bits } } # [ doc = "Bit 6 - End of Conversion Interrupt Mask 6" ] # [ inline ] pub fn eoc6 ( & self ) -> EOC6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC6R { bits } } # [ doc = "Bit 7 - End of Conversion Interrupt Mask 7" ] # [ inline ] pub fn eoc7 ( & self ) -> EOC7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC7R { bits } } # [ doc = "Bit 8 - End of Conversion Interrupt Mask 8" ] # [ inline ] pub fn eoc8 ( & self ) -> EOC8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC8R { bits } } # [ doc = "Bit 9 - End of Conversion Interrupt Mask 9" ] # [ inline ] pub fn eoc9 ( & self ) -> EOC9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC9R { bits } } # [ doc = "Bit 10 - End of Conversion Interrupt Mask 10" ] # [ inline ] pub fn eoc10 ( & self ) -> EOC10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC10R { bits } } # [ doc = "Bit 11 - End of Conversion Interrupt Mask 11" ] # [ inline ] pub fn eoc11 ( & self ) -> EOC11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC11R { bits } } # [ doc = "Bit 12 - End of Conversion Interrupt Mask 12" ] # [ inline ] pub fn eoc12 ( & self ) -> EOC12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC12R { bits } } # [ doc = "Bit 13 - End of Conversion Interrupt Mask 13" ] # [ inline ] pub fn eoc13 ( & self ) -> EOC13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC13R { bits } } # [ doc = "Bit 14 - End of Conversion Interrupt Mask 14" ] # [ inline ] pub fn eoc14 ( & self ) -> EOC14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC14R { bits } } # [ doc = "Bit 15 - End of Conversion Interrupt Mask 15" ] # [ inline ] pub fn eoc15 ( & self ) -> EOC15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC15R { bits } } # [ doc = "Bit 24 - Data Ready Interrupt Mask" ] # [ inline ] pub fn drdy ( & self ) -> DRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRDYR { bits } } # [ doc = "Bit 25 - General Overrun Error Interrupt Mask" ] # [ inline ] pub fn govre ( & self ) -> GOVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GOVRER { bits } } # [ doc = "Bit 26 - Comparison Event Interrupt Mask" ] # [ inline ] pub fn compe ( & self ) -> COMPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COMPER { bits } } # [ doc = "Bit 27 - End of Receive Buffer Interrupt Mask" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 28 - Receive Buffer Full Interrupt Mask" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ 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 EOC0R { bits : bool , } impl EOC0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC1R { bits : bool , } impl EOC1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC2R { bits : bool , } impl EOC2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC3R { bits : bool , } impl EOC3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC4R { bits : bool , } impl EOC4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC5R { bits : bool , } impl EOC5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC6R { bits : bool , } impl EOC6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC7R { bits : bool , } impl EOC7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC8R { bits : bool , } impl EOC8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC9R { bits : bool , } impl EOC9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC10R { bits : bool , } impl EOC10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC11R { bits : bool , } impl EOC11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC12R { bits : bool , } impl EOC12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC13R { bits : bool , } impl EOC13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC14R { bits : bool , } impl EOC14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EOC15R { bits : bool , } impl EOC15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DRDYR { bits : bool , } impl DRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct GOVRER { bits : bool , } impl GOVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct COMPER { bits : bool , } impl COMPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - End of Conversion 0" ] # [ inline ] pub fn eoc0 ( & self ) -> EOC0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC0R { bits } } # [ doc = "Bit 1 - End of Conversion 1" ] # [ inline ] pub fn eoc1 ( & self ) -> EOC1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC1R { bits } } # [ doc = "Bit 2 - End of Conversion 2" ] # [ inline ] pub fn eoc2 ( & self ) -> EOC2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC2R { bits } } # [ doc = "Bit 3 - End of Conversion 3" ] # [ inline ] pub fn eoc3 ( & self ) -> EOC3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC3R { bits } } # [ doc = "Bit 4 - End of Conversion 4" ] # [ inline ] pub fn eoc4 ( & self ) -> EOC4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC4R { bits } } # [ doc = "Bit 5 - End of Conversion 5" ] # [ inline ] pub fn eoc5 ( & self ) -> EOC5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC5R { bits } } # [ doc = "Bit 6 - End of Conversion 6" ] # [ inline ] pub fn eoc6 ( & self ) -> EOC6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC6R { bits } } # [ doc = "Bit 7 - End of Conversion 7" ] # [ inline ] pub fn eoc7 ( & self ) -> EOC7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC7R { bits } } # [ doc = "Bit 8 - End of Conversion 8" ] # [ inline ] pub fn eoc8 ( & self ) -> EOC8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC8R { bits } } # [ doc = "Bit 9 - End of Conversion 9" ] # [ inline ] pub fn eoc9 ( & self ) -> EOC9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC9R { bits } } # [ doc = "Bit 10 - End of Conversion 10" ] # [ inline ] pub fn eoc10 ( & self ) -> EOC10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC10R { bits } } # [ doc = "Bit 11 - End of Conversion 11" ] # [ inline ] pub fn eoc11 ( & self ) -> EOC11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC11R { bits } } # [ doc = "Bit 12 - End of Conversion 12" ] # [ inline ] pub fn eoc12 ( & self ) -> EOC12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC12R { bits } } # [ doc = "Bit 13 - End of Conversion 13" ] # [ inline ] pub fn eoc13 ( & self ) -> EOC13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC13R { bits } } # [ doc = "Bit 14 - End of Conversion 14" ] # [ inline ] pub fn eoc14 ( & self ) -> EOC14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC14R { bits } } # [ doc = "Bit 15 - End of Conversion 15" ] # [ inline ] pub fn eoc15 ( & self ) -> EOC15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOC15R { bits } } # [ doc = "Bit 24 - Data Ready" ] # [ inline ] pub fn drdy ( & self ) -> DRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DRDYR { bits } } # [ doc = "Bit 25 - General Overrun Error" ] # [ inline ] pub fn govre ( & self ) -> GOVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; GOVRER { bits } } # [ doc = "Bit 26 - Comparison Error" ] # [ inline ] pub fn compe ( & self ) -> COMPER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; COMPER { bits } } # [ doc = "Bit 27 - End of RX Buffer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 28 - RX Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Overrun Status Register" ] pub struct OVER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Overrun Status Register" ] pub mod over { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OVER { # [ 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 OVRE0R { bits : bool , } impl OVRE0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE1R { bits : bool , } impl OVRE1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE2R { bits : bool , } impl OVRE2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE3R { bits : bool , } impl OVRE3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE4R { bits : bool , } impl OVRE4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE5R { bits : bool , } impl OVRE5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE6R { bits : bool , } impl OVRE6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE7R { bits : bool , } impl OVRE7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE8R { bits : bool , } impl OVRE8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE9R { bits : bool , } impl OVRE9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE10R { bits : bool , } impl OVRE10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE11R { bits : bool , } impl OVRE11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE12R { bits : bool , } impl OVRE12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE13R { bits : bool , } impl OVRE13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE14R { bits : bool , } impl OVRE14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRE15R { bits : bool , } impl OVRE15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Overrun Error 0" ] # [ inline ] pub fn ovre0 ( & self ) -> OVRE0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE0R { bits } } # [ doc = "Bit 1 - Overrun Error 1" ] # [ inline ] pub fn ovre1 ( & self ) -> OVRE1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE1R { bits } } # [ doc = "Bit 2 - Overrun Error 2" ] # [ inline ] pub fn ovre2 ( & self ) -> OVRE2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE2R { bits } } # [ doc = "Bit 3 - Overrun Error 3" ] # [ inline ] pub fn ovre3 ( & self ) -> OVRE3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE3R { bits } } # [ doc = "Bit 4 - Overrun Error 4" ] # [ inline ] pub fn ovre4 ( & self ) -> OVRE4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE4R { bits } } # [ doc = "Bit 5 - Overrun Error 5" ] # [ inline ] pub fn ovre5 ( & self ) -> OVRE5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE5R { bits } } # [ doc = "Bit 6 - Overrun Error 6" ] # [ inline ] pub fn ovre6 ( & self ) -> OVRE6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE6R { bits } } # [ doc = "Bit 7 - Overrun Error 7" ] # [ inline ] pub fn ovre7 ( & self ) -> OVRE7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE7R { bits } } # [ doc = "Bit 8 - Overrun Error 8" ] # [ inline ] pub fn ovre8 ( & self ) -> OVRE8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE8R { bits } } # [ doc = "Bit 9 - Overrun Error 9" ] # [ inline ] pub fn ovre9 ( & self ) -> OVRE9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE9R { bits } } # [ doc = "Bit 10 - Overrun Error 10" ] # [ inline ] pub fn ovre10 ( & self ) -> OVRE10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE10R { bits } } # [ doc = "Bit 11 - Overrun Error 11" ] # [ inline ] pub fn ovre11 ( & self ) -> OVRE11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE11R { bits } } # [ doc = "Bit 12 - Overrun Error 12" ] # [ inline ] pub fn ovre12 ( & self ) -> OVRE12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE12R { bits } } # [ doc = "Bit 13 - Overrun Error 13" ] # [ inline ] pub fn ovre13 ( & self ) -> OVRE13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE13R { bits } } # [ doc = "Bit 14 - Overrun Error 14" ] # [ inline ] pub fn ovre14 ( & self ) -> OVRE14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE14R { bits } } # [ doc = "Bit 15 - Overrun Error 15" ] # [ inline ] pub fn ovre15 ( & self ) -> OVRE15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRE15R { bits } } } } # [ doc = "Extended Mode Register" ] pub struct EMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Extended Mode Register" ] 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 < F > ( & 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 < F > ( & 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 = "Possible values of the field `CMPMODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CMPMODER { # [ doc = "Generates an event when the converted data is lower than the low threshold of the window." ] LOW , # [ doc = "Generates an event when the converted data is higher than the high threshold of the window." ] HIGH , # [ doc = "Generates an event when the converted data is in the comparison window." ] IN , # [ doc = "Generates an event when the converted data is out of the comparison window." ] OUT } impl CMPMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CMPMODER :: LOW => 0 , CMPMODER :: HIGH => 0x01 , CMPMODER :: IN => 0x02 , CMPMODER :: OUT => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CMPMODER { match value { 0 => CMPMODER :: LOW , 1 => CMPMODER :: HIGH , 2 => CMPMODER :: IN , 3 => CMPMODER :: OUT , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `LOW`" ] # [ inline ] pub fn is_low ( & self ) -> bool { * self == CMPMODER :: LOW } # [ doc = "Checks if the value of the field is `HIGH`" ] # [ inline ] pub fn is_high ( & self ) -> bool { * self == CMPMODER :: HIGH } # [ doc = "Checks if the value of the field is `IN`" ] # [ inline ] pub fn is_in_ ( & self ) -> bool { * self == CMPMODER :: IN } # [ doc = "Checks if the value of the field is `OUT`" ] # [ inline ] pub fn is_out ( & self ) -> bool { * self == CMPMODER :: OUT } } # [ doc = r" Value of the field" ] pub struct CMPSELR { bits : u8 , } impl CMPSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CMPALLR { bits : bool , } impl CMPALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMPFILTERR { bits : u8 , } impl CMPFILTERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TAGR { bits : bool , } impl TAGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CMPMODE`" ] pub enum CMPMODEW { # [ doc = "Generates an event when the converted data is lower than the low threshold of the window." ] LOW , # [ doc = "Generates an event when the converted data is higher than the high threshold of the window." ] HIGH , # [ doc = "Generates an event when the converted data is in the comparison window." ] IN , # [ doc = "Generates an event when the converted data is out of the comparison window." ] OUT } impl CMPMODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CMPMODEW :: LOW => 0 , CMPMODEW :: HIGH => 1 , CMPMODEW :: IN => 2 , CMPMODEW :: OUT => 3 } } } # [ doc = r" Proxy" ] pub struct _CMPMODEW < 'a > { w : & 'a mut W , } impl < 'a > _CMPMODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CMPMODEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Generates an event when the converted data is lower than the low threshold of the window." ] # [ inline ] pub fn low ( self ) -> & 'a mut W { self . variant ( CMPMODEW :: LOW ) } # [ doc = "Generates an event when the converted data is higher than the high threshold of the window." ] # [ inline ] pub fn high ( self ) -> & 'a mut W { self . variant ( CMPMODEW :: HIGH ) } # [ doc = "Generates an event when the converted data is in the comparison window." ] # [ inline ] pub fn in_ ( self ) -> & 'a mut W { self . variant ( CMPMODEW :: IN ) } # [ doc = "Generates an event when the converted data is out of the comparison window." ] # [ inline ] pub fn out ( self ) -> & 'a mut W { self . variant ( CMPMODEW :: OUT ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _CMPSELW < 'a > { w : & 'a mut W , } impl < 'a > _CMPSELW < '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 _CMPALLW < 'a > { w : & 'a mut W , } impl < 'a > _CMPALLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMPFILTERW < 'a > { w : & 'a mut W , } impl < 'a > _CMPFILTERW < '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 _TAGW < 'a > { w : & 'a mut W , } impl < 'a > _TAGW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:1 - Comparison Mode" ] # [ inline ] pub fn cmpmode ( & self ) -> CMPMODER { CMPMODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:7 - Comparison Selected Channel" ] # [ inline ] pub fn cmpsel ( & self ) -> CMPSELR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CMPSELR { bits } } # [ doc = "Bit 9 - Compare All Channels" ] # [ inline ] pub fn cmpall ( & self ) -> CMPALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMPALLR { bits } } # [ doc = "Bits 12:13 - Compare Event Filtering" ] # [ inline ] pub fn cmpfilter ( & self ) -> CMPFILTERR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CMPFILTERR { bits } } # [ doc = "Bit 24 - TAG of the ADC_LDCR register" ] # [ inline ] pub fn tag ( & self ) -> TAGR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TAGR { 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 - Comparison Mode" ] # [ inline ] pub fn cmpmode ( & mut self ) -> _CMPMODEW { _CMPMODEW { w : self } } # [ doc = "Bits 4:7 - Comparison Selected Channel" ] # [ inline ] pub fn cmpsel ( & mut self ) -> _CMPSELW { _CMPSELW { w : self } } # [ doc = "Bit 9 - Compare All Channels" ] # [ inline ] pub fn cmpall ( & mut self ) -> _CMPALLW { _CMPALLW { w : self } } # [ doc = "Bits 12:13 - Compare Event Filtering" ] # [ inline ] pub fn cmpfilter ( & mut self ) -> _CMPFILTERW { _CMPFILTERW { w : self } } # [ doc = "Bit 24 - TAG of the ADC_LDCR register" ] # [ inline ] pub fn tag ( & mut self ) -> _TAGW { _TAGW { w : self } } } } # [ doc = "Compare Window Register" ] pub struct CWR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Compare Window Register" ] pub mod cwr { # [ 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 :: CWR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 LOWTHRESR { bits : u16 , } impl LOWTHRESR { # [ 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 HIGHTHRESR { bits : u16 , } impl HIGHTHRESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _LOWTHRESW < 'a > { w : & 'a mut W , } impl < 'a > _LOWTHRESW < '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 _HIGHTHRESW < 'a > { w : & 'a mut W , } impl < 'a > _HIGHTHRESW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:11 - Low Threshold" ] # [ inline ] pub fn lowthres ( & self ) -> LOWTHRESR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; LOWTHRESR { bits } } # [ doc = "Bits 16:27 - High Threshold" ] # [ inline ] pub fn highthres ( & self ) -> HIGHTHRESR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; HIGHTHRESR { 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 - Low Threshold" ] # [ inline ] pub fn lowthres ( & mut self ) -> _LOWTHRESW { _LOWTHRESW { w : self } } # [ doc = "Bits 16:27 - High Threshold" ] # [ inline ] pub fn highthres ( & mut self ) -> _HIGHTHRESW { _HIGHTHRESW { w : self } } } } # [ doc = "Channel Gain Register" ] pub struct CGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Gain Register" ] pub mod cgr { # [ 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 :: CGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 GAIN0R { bits : u8 , } impl GAIN0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN1R { bits : u8 , } impl GAIN1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN2R { bits : u8 , } impl GAIN2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN3R { bits : u8 , } impl GAIN3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN4R { bits : u8 , } impl GAIN4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN5R { bits : u8 , } impl GAIN5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN6R { bits : u8 , } impl GAIN6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN7R { bits : u8 , } impl GAIN7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN8R { bits : u8 , } impl GAIN8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN9R { bits : u8 , } impl GAIN9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN10R { bits : u8 , } impl GAIN10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN11R { bits : u8 , } impl GAIN11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN12R { bits : u8 , } impl GAIN12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN13R { bits : u8 , } impl GAIN13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN14R { bits : u8 , } impl GAIN14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct GAIN15R { bits : u8 , } impl GAIN15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _GAIN0W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN0W < '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 _GAIN1W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN1W < '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 _GAIN2W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN2W < '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 _GAIN3W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN3W < '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 _GAIN4W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN4W < '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 _GAIN5W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN5W < '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 _GAIN6W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN6W < '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 _GAIN7W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN7W < '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 _GAIN8W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN8W < '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 _GAIN9W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN9W < '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 _GAIN10W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN10W < '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 _GAIN11W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN11W < '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 _GAIN12W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN12W < '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 _GAIN13W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN13W < '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 _GAIN14W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN14W < '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 _GAIN15W < 'a > { w : & 'a mut W , } impl < 'a > _GAIN15W < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Gain for Channel 0" ] # [ inline ] pub fn gain0 ( & self ) -> GAIN0R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN0R { bits } } # [ doc = "Bits 2:3 - Gain for Channel 1" ] # [ inline ] pub fn gain1 ( & self ) -> GAIN1R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN1R { bits } } # [ doc = "Bits 4:5 - Gain for Channel 2" ] # [ inline ] pub fn gain2 ( & self ) -> GAIN2R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN2R { bits } } # [ doc = "Bits 6:7 - Gain for Channel 3" ] # [ inline ] pub fn gain3 ( & self ) -> GAIN3R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN3R { bits } } # [ doc = "Bits 8:9 - Gain for Channel 4" ] # [ inline ] pub fn gain4 ( & self ) -> GAIN4R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN4R { bits } } # [ doc = "Bits 10:11 - Gain for Channel 5" ] # [ inline ] pub fn gain5 ( & self ) -> GAIN5R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN5R { bits } } # [ doc = "Bits 12:13 - Gain for Channel 6" ] # [ inline ] pub fn gain6 ( & self ) -> GAIN6R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN6R { bits } } # [ doc = "Bits 14:15 - Gain for Channel 7" ] # [ inline ] pub fn gain7 ( & self ) -> GAIN7R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN7R { bits } } # [ doc = "Bits 16:17 - Gain for Channel 8" ] # [ inline ] pub fn gain8 ( & self ) -> GAIN8R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN8R { bits } } # [ doc = "Bits 18:19 - Gain for Channel 9" ] # [ inline ] pub fn gain9 ( & self ) -> GAIN9R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN9R { bits } } # [ doc = "Bits 20:21 - Gain for Channel 10" ] # [ inline ] pub fn gain10 ( & self ) -> GAIN10R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN10R { bits } } # [ doc = "Bits 22:23 - Gain for Channel 11" ] # [ inline ] pub fn gain11 ( & self ) -> GAIN11R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN11R { bits } } # [ doc = "Bits 24:25 - Gain for Channel 12" ] # [ inline ] pub fn gain12 ( & self ) -> GAIN12R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN12R { bits } } # [ doc = "Bits 26:27 - Gain for Channel 13" ] # [ inline ] pub fn gain13 ( & self ) -> GAIN13R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN13R { bits } } # [ doc = "Bits 28:29 - Gain for Channel 14" ] # [ inline ] pub fn gain14 ( & self ) -> GAIN14R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN14R { bits } } # [ doc = "Bits 30:31 - Gain for Channel 15" ] # [ inline ] pub fn gain15 ( & self ) -> GAIN15R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; GAIN15R { 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 - Gain for Channel 0" ] # [ inline ] pub fn gain0 ( & mut self ) -> _GAIN0W { _GAIN0W { w : self } } # [ doc = "Bits 2:3 - Gain for Channel 1" ] # [ inline ] pub fn gain1 ( & mut self ) -> _GAIN1W { _GAIN1W { w : self } } # [ doc = "Bits 4:5 - Gain for Channel 2" ] # [ inline ] pub fn gain2 ( & mut self ) -> _GAIN2W { _GAIN2W { w : self } } # [ doc = "Bits 6:7 - Gain for Channel 3" ] # [ inline ] pub fn gain3 ( & mut self ) -> _GAIN3W { _GAIN3W { w : self } } # [ doc = "Bits 8:9 - Gain for Channel 4" ] # [ inline ] pub fn gain4 ( & mut self ) -> _GAIN4W { _GAIN4W { w : self } } # [ doc = "Bits 10:11 - Gain for Channel 5" ] # [ inline ] pub fn gain5 ( & mut self ) -> _GAIN5W { _GAIN5W { w : self } } # [ doc = "Bits 12:13 - Gain for Channel 6" ] # [ inline ] pub fn gain6 ( & mut self ) -> _GAIN6W { _GAIN6W { w : self } } # [ doc = "Bits 14:15 - Gain for Channel 7" ] # [ inline ] pub fn gain7 ( & mut self ) -> _GAIN7W { _GAIN7W { w : self } } # [ doc = "Bits 16:17 - Gain for Channel 8" ] # [ inline ] pub fn gain8 ( & mut self ) -> _GAIN8W { _GAIN8W { w : self } } # [ doc = "Bits 18:19 - Gain for Channel 9" ] # [ inline ] pub fn gain9 ( & mut self ) -> _GAIN9W { _GAIN9W { w : self } } # [ doc = "Bits 20:21 - Gain for Channel 10" ] # [ inline ] pub fn gain10 ( & mut self ) -> _GAIN10W { _GAIN10W { w : self } } # [ doc = "Bits 22:23 - Gain for Channel 11" ] # [ inline ] pub fn gain11 ( & mut self ) -> _GAIN11W { _GAIN11W { w : self } } # [ doc = "Bits 24:25 - Gain for Channel 12" ] # [ inline ] pub fn gain12 ( & mut self ) -> _GAIN12W { _GAIN12W { w : self } } # [ doc = "Bits 26:27 - Gain for Channel 13" ] # [ inline ] pub fn gain13 ( & mut self ) -> _GAIN13W { _GAIN13W { w : self } } # [ doc = "Bits 28:29 - Gain for Channel 14" ] # [ inline ] pub fn gain14 ( & mut self ) -> _GAIN14W { _GAIN14W { w : self } } # [ doc = "Bits 30:31 - Gain for Channel 15" ] # [ inline ] pub fn gain15 ( & mut self ) -> _GAIN15W { _GAIN15W { w : self } } } } # [ doc = "Channel Offset Register" ] pub struct COR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Offset Register" ] pub mod cor { # [ 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 :: COR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 OFF0R { bits : bool , } impl OFF0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF1R { bits : bool , } impl OFF1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF2R { bits : bool , } impl OFF2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF3R { bits : bool , } impl OFF3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF4R { bits : bool , } impl OFF4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF5R { bits : bool , } impl OFF5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF6R { bits : bool , } impl OFF6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF7R { bits : bool , } impl OFF7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF8R { bits : bool , } impl OFF8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF9R { bits : bool , } impl OFF9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF10R { bits : bool , } impl OFF10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF11R { bits : bool , } impl OFF11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF12R { bits : bool , } impl OFF12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF13R { bits : bool , } impl OFF13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF14R { bits : bool , } impl OFF14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OFF15R { bits : bool , } impl OFF15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF0R { bits : bool , } impl DIFF0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF1R { bits : bool , } impl DIFF1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF2R { bits : bool , } impl DIFF2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF3R { bits : bool , } impl DIFF3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF4R { bits : bool , } impl DIFF4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF5R { bits : bool , } impl DIFF5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF6R { bits : bool , } impl DIFF6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF7R { bits : bool , } impl DIFF7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF8R { bits : bool , } impl DIFF8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF9R { bits : bool , } impl DIFF9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF10R { bits : bool , } impl DIFF10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF11R { bits : bool , } impl DIFF11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF12R { bits : bool , } impl DIFF12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF13R { bits : bool , } impl DIFF13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF14R { bits : bool , } impl DIFF14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DIFF15R { bits : bool , } impl DIFF15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _OFF0W < 'a > { w : & 'a mut W , } impl < 'a > _OFF0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF1W < 'a > { w : & 'a mut W , } impl < 'a > _OFF1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF2W < 'a > { w : & 'a mut W , } impl < 'a > _OFF2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF3W < 'a > { w : & 'a mut W , } impl < 'a > _OFF3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF4W < 'a > { w : & 'a mut W , } impl < 'a > _OFF4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF5W < 'a > { w : & 'a mut W , } impl < 'a > _OFF5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF6W < 'a > { w : & 'a mut W , } impl < 'a > _OFF6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF7W < 'a > { w : & 'a mut W , } impl < 'a > _OFF7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF8W < 'a > { w : & 'a mut W , } impl < 'a > _OFF8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF9W < 'a > { w : & 'a mut W , } impl < 'a > _OFF9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF10W < 'a > { w : & 'a mut W , } impl < 'a > _OFF10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF11W < 'a > { w : & 'a mut W , } impl < 'a > _OFF11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF12W < 'a > { w : & 'a mut W , } impl < 'a > _OFF12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF13W < 'a > { w : & 'a mut W , } impl < 'a > _OFF13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF14W < 'a > { w : & 'a mut W , } impl < 'a > _OFF14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OFF15W < 'a > { w : & 'a mut W , } impl < 'a > _OFF15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF0W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF1W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF2W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF3W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF4W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF5W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF6W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF7W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF8W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF9W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF10W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF11W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF12W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF13W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF14W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIFF15W < 'a > { w : & 'a mut W , } impl < 'a > _DIFF15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Offset for channel 0" ] # [ inline ] pub fn off0 ( & self ) -> OFF0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF0R { bits } } # [ doc = "Bit 1 - Offset for channel 1" ] # [ inline ] pub fn off1 ( & self ) -> OFF1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF1R { bits } } # [ doc = "Bit 2 - Offset for channel 2" ] # [ inline ] pub fn off2 ( & self ) -> OFF2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF2R { bits } } # [ doc = "Bit 3 - Offset for channel 3" ] # [ inline ] pub fn off3 ( & self ) -> OFF3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF3R { bits } } # [ doc = "Bit 4 - Offset for channel 4" ] # [ inline ] pub fn off4 ( & self ) -> OFF4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF4R { bits } } # [ doc = "Bit 5 - Offset for channel 5" ] # [ inline ] pub fn off5 ( & self ) -> OFF5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF5R { bits } } # [ doc = "Bit 6 - Offset for channel 6" ] # [ inline ] pub fn off6 ( & self ) -> OFF6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF6R { bits } } # [ doc = "Bit 7 - Offset for channel 7" ] # [ inline ] pub fn off7 ( & self ) -> OFF7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF7R { bits } } # [ doc = "Bit 8 - Offset for channel 8" ] # [ inline ] pub fn off8 ( & self ) -> OFF8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF8R { bits } } # [ doc = "Bit 9 - Offset for channel 9" ] # [ inline ] pub fn off9 ( & self ) -> OFF9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF9R { bits } } # [ doc = "Bit 10 - Offset for channel 10" ] # [ inline ] pub fn off10 ( & self ) -> OFF10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF10R { bits } } # [ doc = "Bit 11 - Offset for channel 11" ] # [ inline ] pub fn off11 ( & self ) -> OFF11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF11R { bits } } # [ doc = "Bit 12 - Offset for channel 12" ] # [ inline ] pub fn off12 ( & self ) -> OFF12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF12R { bits } } # [ doc = "Bit 13 - Offset for channel 13" ] # [ inline ] pub fn off13 ( & self ) -> OFF13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF13R { bits } } # [ doc = "Bit 14 - Offset for channel 14" ] # [ inline ] pub fn off14 ( & self ) -> OFF14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF14R { bits } } # [ doc = "Bit 15 - Offset for channel 15" ] # [ inline ] pub fn off15 ( & self ) -> OFF15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OFF15R { bits } } # [ doc = "Bit 16 - Differential inputs for channel 0" ] # [ inline ] pub fn diff0 ( & self ) -> DIFF0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF0R { bits } } # [ doc = "Bit 17 - Differential inputs for channel 1" ] # [ inline ] pub fn diff1 ( & self ) -> DIFF1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF1R { bits } } # [ doc = "Bit 18 - Differential inputs for channel 2" ] # [ inline ] pub fn diff2 ( & self ) -> DIFF2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF2R { bits } } # [ doc = "Bit 19 - Differential inputs for channel 3" ] # [ inline ] pub fn diff3 ( & self ) -> DIFF3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF3R { bits } } # [ doc = "Bit 20 - Differential inputs for channel 4" ] # [ inline ] pub fn diff4 ( & self ) -> DIFF4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF4R { bits } } # [ doc = "Bit 21 - Differential inputs for channel 5" ] # [ inline ] pub fn diff5 ( & self ) -> DIFF5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF5R { bits } } # [ doc = "Bit 22 - Differential inputs for channel 6" ] # [ inline ] pub fn diff6 ( & self ) -> DIFF6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF6R { bits } } # [ doc = "Bit 23 - Differential inputs for channel 7" ] # [ inline ] pub fn diff7 ( & self ) -> DIFF7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF7R { bits } } # [ doc = "Bit 24 - Differential inputs for channel 8" ] # [ inline ] pub fn diff8 ( & self ) -> DIFF8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF8R { bits } } # [ doc = "Bit 25 - Differential inputs for channel 9" ] # [ inline ] pub fn diff9 ( & self ) -> DIFF9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF9R { bits } } # [ doc = "Bit 26 - Differential inputs for channel 10" ] # [ inline ] pub fn diff10 ( & self ) -> DIFF10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF10R { bits } } # [ doc = "Bit 27 - Differential inputs for channel 11" ] # [ inline ] pub fn diff11 ( & self ) -> DIFF11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF11R { bits } } # [ doc = "Bit 28 - Differential inputs for channel 12" ] # [ inline ] pub fn diff12 ( & self ) -> DIFF12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF12R { bits } } # [ doc = "Bit 29 - Differential inputs for channel 13" ] # [ inline ] pub fn diff13 ( & self ) -> DIFF13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF13R { bits } } # [ doc = "Bit 30 - Differential inputs for channel 14" ] # [ inline ] pub fn diff14 ( & self ) -> DIFF14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF14R { bits } } # [ doc = "Bit 31 - Differential inputs for channel 15" ] # [ inline ] pub fn diff15 ( & self ) -> DIFF15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DIFF15R { 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 - Offset for channel 0" ] # [ inline ] pub fn off0 ( & mut self ) -> _OFF0W { _OFF0W { w : self } } # [ doc = "Bit 1 - Offset for channel 1" ] # [ inline ] pub fn off1 ( & mut self ) -> _OFF1W { _OFF1W { w : self } } # [ doc = "Bit 2 - Offset for channel 2" ] # [ inline ] pub fn off2 ( & mut self ) -> _OFF2W { _OFF2W { w : self } } # [ doc = "Bit 3 - Offset for channel 3" ] # [ inline ] pub fn off3 ( & mut self ) -> _OFF3W { _OFF3W { w : self } } # [ doc = "Bit 4 - Offset for channel 4" ] # [ inline ] pub fn off4 ( & mut self ) -> _OFF4W { _OFF4W { w : self } } # [ doc = "Bit 5 - Offset for channel 5" ] # [ inline ] pub fn off5 ( & mut self ) -> _OFF5W { _OFF5W { w : self } } # [ doc = "Bit 6 - Offset for channel 6" ] # [ inline ] pub fn off6 ( & mut self ) -> _OFF6W { _OFF6W { w : self } } # [ doc = "Bit 7 - Offset for channel 7" ] # [ inline ] pub fn off7 ( & mut self ) -> _OFF7W { _OFF7W { w : self } } # [ doc = "Bit 8 - Offset for channel 8" ] # [ inline ] pub fn off8 ( & mut self ) -> _OFF8W { _OFF8W { w : self } } # [ doc = "Bit 9 - Offset for channel 9" ] # [ inline ] pub fn off9 ( & mut self ) -> _OFF9W { _OFF9W { w : self } } # [ doc = "Bit 10 - Offset for channel 10" ] # [ inline ] pub fn off10 ( & mut self ) -> _OFF10W { _OFF10W { w : self } } # [ doc = "Bit 11 - Offset for channel 11" ] # [ inline ] pub fn off11 ( & mut self ) -> _OFF11W { _OFF11W { w : self } } # [ doc = "Bit 12 - Offset for channel 12" ] # [ inline ] pub fn off12 ( & mut self ) -> _OFF12W { _OFF12W { w : self } } # [ doc = "Bit 13 - Offset for channel 13" ] # [ inline ] pub fn off13 ( & mut self ) -> _OFF13W { _OFF13W { w : self } } # [ doc = "Bit 14 - Offset for channel 14" ] # [ inline ] pub fn off14 ( & mut self ) -> _OFF14W { _OFF14W { w : self } } # [ doc = "Bit 15 - Offset for channel 15" ] # [ inline ] pub fn off15 ( & mut self ) -> _OFF15W { _OFF15W { w : self } } # [ doc = "Bit 16 - Differential inputs for channel 0" ] # [ inline ] pub fn diff0 ( & mut self ) -> _DIFF0W { _DIFF0W { w : self } } # [ doc = "Bit 17 - Differential inputs for channel 1" ] # [ inline ] pub fn diff1 ( & mut self ) -> _DIFF1W { _DIFF1W { w : self } } # [ doc = "Bit 18 - Differential inputs for channel 2" ] # [ inline ] pub fn diff2 ( & mut self ) -> _DIFF2W { _DIFF2W { w : self } } # [ doc = "Bit 19 - Differential inputs for channel 3" ] # [ inline ] pub fn diff3 ( & mut self ) -> _DIFF3W { _DIFF3W { w : self } } # [ doc = "Bit 20 - Differential inputs for channel 4" ] # [ inline ] pub fn diff4 ( & mut self ) -> _DIFF4W { _DIFF4W { w : self } } # [ doc = "Bit 21 - Differential inputs for channel 5" ] # [ inline ] pub fn diff5 ( & mut self ) -> _DIFF5W { _DIFF5W { w : self } } # [ doc = "Bit 22 - Differential inputs for channel 6" ] # [ inline ] pub fn diff6 ( & mut self ) -> _DIFF6W { _DIFF6W { w : self } } # [ doc = "Bit 23 - Differential inputs for channel 7" ] # [ inline ] pub fn diff7 ( & mut self ) -> _DIFF7W { _DIFF7W { w : self } } # [ doc = "Bit 24 - Differential inputs for channel 8" ] # [ inline ] pub fn diff8 ( & mut self ) -> _DIFF8W { _DIFF8W { w : self } } # [ doc = "Bit 25 - Differential inputs for channel 9" ] # [ inline ] pub fn diff9 ( & mut self ) -> _DIFF9W { _DIFF9W { w : self } } # [ doc = "Bit 26 - Differential inputs for channel 10" ] # [ inline ] pub fn diff10 ( & mut self ) -> _DIFF10W { _DIFF10W { w : self } } # [ doc = "Bit 27 - Differential inputs for channel 11" ] # [ inline ] pub fn diff11 ( & mut self ) -> _DIFF11W { _DIFF11W { w : self } } # [ doc = "Bit 28 - Differential inputs for channel 12" ] # [ inline ] pub fn diff12 ( & mut self ) -> _DIFF12W { _DIFF12W { w : self } } # [ doc = "Bit 29 - Differential inputs for channel 13" ] # [ inline ] pub fn diff13 ( & mut self ) -> _DIFF13W { _DIFF13W { w : self } } # [ doc = "Bit 30 - Differential inputs for channel 14" ] # [ inline ] pub fn diff14 ( & mut self ) -> _DIFF14W { _DIFF14W { w : self } } # [ doc = "Bit 31 - Differential inputs for channel 15" ] # [ inline ] pub fn diff15 ( & mut self ) -> _DIFF15W { _DIFF15W { w : self } } } } # [ doc = "Channel Data Register" ] pub struct CDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Data Register" ] pub mod cdr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CDR { # [ 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:11 - Converted Data" ] # [ inline ] pub fn data ( & self ) -> DATAR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DATAR { bits } } } } # [ doc = "Analog Control Register" ] pub struct ACR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Analog 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 < F > ( & 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 < F > ( & 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 TSONR { bits : bool , } impl TSONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct IBCTLR { bits : u8 , } impl IBCTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _TSONW < 'a > { w : & 'a mut W , } impl < 'a > _TSONW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _IBCTLW < 'a > { w : & 'a mut W , } impl < 'a > _IBCTLW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 4 - Temperature Sensor On" ] # [ inline ] pub fn tson ( & self ) -> TSONR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TSONR { bits } } # [ doc = "Bits 8:9 - ADC Bias Current Control" ] # [ inline ] pub fn ibctl ( & self ) -> IBCTLR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IBCTLR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100 } } # [ 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 - Temperature Sensor On" ] # [ inline ] pub fn tson ( & mut self ) -> _TSONW { _TSONW { w : self } } # [ doc = "Bits 8:9 - ADC Bias Current Control" ] # [ inline ] pub fn ibctl ( & mut self ) -> _IBCTLW { _IBCTLW { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0" ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0041_4443 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 4277315 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0" ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 4277315 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0" ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "DMA Controller" ] pub struct DMAC { _marker : PhantomData < * const ( ) > } unsafe impl Send for DMAC { } impl DMAC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const dmac :: RegisterBlock { 0x400c_4000 as * const _ } } impl Deref for DMAC { type Target = dmac :: RegisterBlock ; fn deref ( & self ) -> & dmac :: RegisterBlock { unsafe { & * DMAC :: ptr ( ) } } } # [ doc = "DMA Controller" ] pub mod dmac { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - DMAC Global Configuration Register" ] pub gcfg : GCFG , # [ doc = "0x04 - DMAC Enable Register" ] pub en : EN , # [ doc = "0x08 - DMAC Software Single Request Register" ] pub sreq : SREQ , # [ doc = "0x0c - DMAC Software Chunk Transfer Request Register" ] pub creq : CREQ , # [ doc = "0x10 - DMAC Software Last Transfer Flag Register" ] pub last : LAST , _reserved5 : [ u8 ; 4usize ] , # [ doc = "0x18 - DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Enable register." ] pub ebcier : EBCIER , # [ doc = "0x1c - DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Disable register." ] pub ebcidr : EBCIDR , # [ doc = "0x20 - DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Mask Register." ] pub ebcimr : EBCIMR , # [ doc = "0x24 - DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Status Register." ] pub ebcisr : EBCISR , # [ doc = "0x28 - DMAC Channel Handler Enable Register" ] pub cher : CHER , # [ doc = "0x2c - DMAC Channel Handler Disable Register" ] pub chdr : CHDR , # [ doc = "0x30 - DMAC Channel Handler Status Register" ] pub chsr : CHSR , _reserved12 : [ u8 ; 8usize ] , # [ doc = "0x3c - DMAC Channel Source Address Register (ch_num = 0)" ] pub saddr0 : SADDR0 , # [ doc = "0x40 - DMAC Channel Destination Address Register (ch_num = 0)" ] pub daddr0 : DADDR0 , # [ doc = "0x44 - DMAC Channel Descriptor Address Register (ch_num = 0)" ] pub dscr0 : DSCR0 , # [ doc = "0x48 - DMAC Channel Control A Register (ch_num = 0)" ] pub ctrla0 : CTRLA0 , # [ doc = "0x4c - DMAC Channel Control B Register (ch_num = 0)" ] pub ctrlb0 : CTRLB0 , # [ doc = "0x50 - DMAC Channel Configuration Register (ch_num = 0)" ] pub cfg0 : CFG0 , _reserved18 : [ u8 ; 16usize ] , # [ doc = "0x64 - DMAC Channel Source Address Register (ch_num = 1)" ] pub saddr1 : SADDR1 , # [ doc = "0x68 - DMAC Channel Destination Address Register (ch_num = 1)" ] pub daddr1 : DADDR1 , # [ doc = "0x6c - DMAC Channel Descriptor Address Register (ch_num = 1)" ] pub dscr1 : DSCR1 , # [ doc = "0x70 - DMAC Channel Control A Register (ch_num = 1)" ] pub ctrla1 : CTRLA1 , # [ doc = "0x74 - DMAC Channel Control B Register (ch_num = 1)" ] pub ctrlb1 : CTRLB1 , # [ doc = "0x78 - DMAC Channel Configuration Register (ch_num = 1)" ] pub cfg1 : CFG1 , _reserved24 : [ u8 ; 16usize ] , # [ doc = "0x8c - DMAC Channel Source Address Register (ch_num = 2)" ] pub saddr2 : SADDR2 , # [ doc = "0x90 - DMAC Channel Destination Address Register (ch_num = 2)" ] pub daddr2 : DADDR2 , # [ doc = "0x94 - DMAC Channel Descriptor Address Register (ch_num = 2)" ] pub dscr2 : DSCR2 , # [ doc = "0x98 - DMAC Channel Control A Register (ch_num = 2)" ] pub ctrla2 : CTRLA2 , # [ doc = "0x9c - DMAC Channel Control B Register (ch_num = 2)" ] pub ctrlb2 : CTRLB2 , # [ doc = "0xa0 - DMAC Channel Configuration Register (ch_num = 2)" ] pub cfg2 : CFG2 , _reserved30 : [ u8 ; 16usize ] , # [ doc = "0xb4 - DMAC Channel Source Address Register (ch_num = 3)" ] pub saddr3 : SADDR3 , # [ doc = "0xb8 - DMAC Channel Destination Address Register (ch_num = 3)" ] pub daddr3 : DADDR3 , # [ doc = "0xbc - DMAC Channel Descriptor Address Register (ch_num = 3)" ] pub dscr3 : DSCR3 , # [ doc = "0xc0 - DMAC Channel Control A Register (ch_num = 3)" ] pub ctrla3 : CTRLA3 , # [ doc = "0xc4 - DMAC Channel Control B Register (ch_num = 3)" ] pub ctrlb3 : CTRLB3 , # [ doc = "0xc8 - DMAC Channel Configuration Register (ch_num = 3)" ] pub cfg3 : CFG3 , _reserved36 : [ u8 ; 16usize ] , # [ doc = "0xdc - DMAC Channel Source Address Register (ch_num = 4)" ] pub saddr4 : SADDR4 , # [ doc = "0xe0 - DMAC Channel Destination Address Register (ch_num = 4)" ] pub daddr4 : DADDR4 , # [ doc = "0xe4 - DMAC Channel Descriptor Address Register (ch_num = 4)" ] pub dscr4 : DSCR4 , # [ doc = "0xe8 - DMAC Channel Control A Register (ch_num = 4)" ] pub ctrla4 : CTRLA4 , # [ doc = "0xec - DMAC Channel Control B Register (ch_num = 4)" ] pub ctrlb4 : CTRLB4 , # [ doc = "0xf0 - DMAC Channel Configuration Register (ch_num = 4)" ] pub cfg4 : CFG4 , _reserved42 : [ u8 ; 16usize ] , # [ doc = "0x104 - DMAC Channel Source Address Register (ch_num = 5)" ] pub saddr5 : SADDR5 , # [ doc = "0x108 - DMAC Channel Destination Address Register (ch_num = 5)" ] pub daddr5 : DADDR5 , # [ doc = "0x10c - DMAC Channel Descriptor Address Register (ch_num = 5)" ] pub dscr5 : DSCR5 , # [ doc = "0x110 - DMAC Channel Control A Register (ch_num = 5)" ] pub ctrla5 : CTRLA5 , # [ doc = "0x114 - DMAC Channel Control B Register (ch_num = 5)" ] pub ctrlb5 : CTRLB5 , # [ doc = "0x118 - DMAC Channel Configuration Register (ch_num = 5)" ] pub cfg5 : CFG5 , _reserved48 : [ u8 ; 200usize ] , # [ doc = "0x1e4 - DMAC Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0x1e8 - DMAC Write Protect Status Register" ] pub wpsr : WPSR , } # [ doc = "DMAC Global Configuration Register" ] pub struct GCFG { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Global Configuration Register" ] pub mod gcfg { # [ 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 :: GCFG { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `ARB_CFG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ARB_CFGR { # [ doc = "Fixed priority arbiter (see \"Basic Definitions\" )" ] FIXED , # [ doc = "Modified round robin arbiter." ] ROUND_ROBIN } impl ARB_CFGR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { ARB_CFGR :: FIXED => false , ARB_CFGR :: ROUND_ROBIN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> ARB_CFGR { match value { false => ARB_CFGR :: FIXED , true => ARB_CFGR :: ROUND_ROBIN , } } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == ARB_CFGR :: FIXED } # [ doc = "Checks if the value of the field is `ROUND_ROBIN`" ] # [ inline ] pub fn is_round_robin ( & self ) -> bool { * self == ARB_CFGR :: ROUND_ROBIN } } # [ doc = "Values that can be written to the field `ARB_CFG`" ] pub enum ARB_CFGW { # [ doc = "Fixed priority arbiter (see \"Basic Definitions\" )" ] FIXED , # [ doc = "Modified round robin arbiter." ] ROUND_ROBIN } impl ARB_CFGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { ARB_CFGW :: FIXED => false , ARB_CFGW :: ROUND_ROBIN => true } } } # [ doc = r" Proxy" ] pub struct _ARB_CFGW < 'a > { w : & 'a mut W , } impl < 'a > _ARB_CFGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ARB_CFGW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Fixed priority arbiter (see \"Basic Definitions\" )" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( ARB_CFGW :: FIXED ) } # [ doc = "Modified round robin arbiter." ] # [ inline ] pub fn round_robin ( self ) -> & 'a mut W { self . variant ( ARB_CFGW :: ROUND_ROBIN ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 4 - Arbiter Configuration" ] # [ inline ] pub fn arb_cfg ( & self ) -> ARB_CFGR { ARB_CFGR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } 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 4 - Arbiter Configuration" ] # [ inline ] pub fn arb_cfg ( & mut self ) -> _ARB_CFGW { _ARB_CFGW { w : self } } } } # [ doc = "DMAC Enable Register" ] pub struct EN { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Enable Register" ] pub mod en { # [ 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 :: EN { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ENABLER { bits : bool , } impl ENABLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _ENABLEW < 'a > { w : & 'a mut W , } impl < 'a > _ENABLEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - General Enable of DMA" ] # [ inline ] pub fn enable ( & self ) -> ENABLER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENABLER { 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 - General Enable of DMA" ] # [ inline ] pub fn enable ( & mut self ) -> _ENABLEW { _ENABLEW { w : self } } } } # [ doc = "DMAC Software Single Request Register" ] pub struct SREQ { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Software Single Request Register" ] pub mod sreq { # [ 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 :: SREQ { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SSREQ0R { bits : bool , } impl SSREQ0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSREQ0R { bits : bool , } impl DSREQ0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SSREQ1R { bits : bool , } impl SSREQ1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSREQ1R { bits : bool , } impl DSREQ1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SSREQ2R { bits : bool , } impl SSREQ2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSREQ2R { bits : bool , } impl DSREQ2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SSREQ3R { bits : bool , } impl SSREQ3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSREQ3R { bits : bool , } impl DSREQ3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SSREQ4R { bits : bool , } impl SSREQ4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSREQ4R { bits : bool , } impl DSREQ4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SSREQ5R { bits : bool , } impl SSREQ5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DSREQ5R { bits : bool , } impl DSREQ5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SSREQ0W < 'a > { w : & 'a mut W , } impl < 'a > _SSREQ0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSREQ0W < 'a > { w : & 'a mut W , } impl < 'a > _DSREQ0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SSREQ1W < 'a > { w : & 'a mut W , } impl < 'a > _SSREQ1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSREQ1W < 'a > { w : & 'a mut W , } impl < 'a > _DSREQ1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SSREQ2W < 'a > { w : & 'a mut W , } impl < 'a > _SSREQ2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSREQ2W < 'a > { w : & 'a mut W , } impl < 'a > _DSREQ2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SSREQ3W < 'a > { w : & 'a mut W , } impl < 'a > _SSREQ3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSREQ3W < 'a > { w : & 'a mut W , } impl < 'a > _DSREQ3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SSREQ4W < 'a > { w : & 'a mut W , } impl < 'a > _SSREQ4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSREQ4W < 'a > { w : & 'a mut W , } impl < 'a > _DSREQ4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SSREQ5W < 'a > { w : & 'a mut W , } impl < 'a > _SSREQ5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DSREQ5W < 'a > { w : & 'a mut W , } impl < 'a > _DSREQ5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Source Request" ] # [ inline ] pub fn ssreq0 ( & self ) -> SSREQ0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SSREQ0R { bits } } # [ doc = "Bit 1 - Destination Request" ] # [ inline ] pub fn dsreq0 ( & self ) -> DSREQ0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSREQ0R { bits } } # [ doc = "Bit 2 - Source Request" ] # [ inline ] pub fn ssreq1 ( & self ) -> SSREQ1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SSREQ1R { bits } } # [ doc = "Bit 3 - Destination Request" ] # [ inline ] pub fn dsreq1 ( & self ) -> DSREQ1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSREQ1R { bits } } # [ doc = "Bit 4 - Source Request" ] # [ inline ] pub fn ssreq2 ( & self ) -> SSREQ2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SSREQ2R { bits } } # [ doc = "Bit 5 - Destination Request" ] # [ inline ] pub fn dsreq2 ( & self ) -> DSREQ2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSREQ2R { bits } } # [ doc = "Bit 6 - Source Request" ] # [ inline ] pub fn ssreq3 ( & self ) -> SSREQ3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SSREQ3R { bits } } # [ doc = "Bit 7 - Destination Request" ] # [ inline ] pub fn dsreq3 ( & self ) -> DSREQ3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSREQ3R { bits } } # [ doc = "Bit 8 - Source Request" ] # [ inline ] pub fn ssreq4 ( & self ) -> SSREQ4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SSREQ4R { bits } } # [ doc = "Bit 9 - Destination Request" ] # [ inline ] pub fn dsreq4 ( & self ) -> DSREQ4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSREQ4R { bits } } # [ doc = "Bit 10 - Source Request" ] # [ inline ] pub fn ssreq5 ( & self ) -> SSREQ5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SSREQ5R { bits } } # [ doc = "Bit 11 - Destination Request" ] # [ inline ] pub fn dsreq5 ( & self ) -> DSREQ5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DSREQ5R { 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 - Source Request" ] # [ inline ] pub fn ssreq0 ( & mut self ) -> _SSREQ0W { _SSREQ0W { w : self } } # [ doc = "Bit 1 - Destination Request" ] # [ inline ] pub fn dsreq0 ( & mut self ) -> _DSREQ0W { _DSREQ0W { w : self } } # [ doc = "Bit 2 - Source Request" ] # [ inline ] pub fn ssreq1 ( & mut self ) -> _SSREQ1W { _SSREQ1W { w : self } } # [ doc = "Bit 3 - Destination Request" ] # [ inline ] pub fn dsreq1 ( & mut self ) -> _DSREQ1W { _DSREQ1W { w : self } } # [ doc = "Bit 4 - Source Request" ] # [ inline ] pub fn ssreq2 ( & mut self ) -> _SSREQ2W { _SSREQ2W { w : self } } # [ doc = "Bit 5 - Destination Request" ] # [ inline ] pub fn dsreq2 ( & mut self ) -> _DSREQ2W { _DSREQ2W { w : self } } # [ doc = "Bit 6 - Source Request" ] # [ inline ] pub fn ssreq3 ( & mut self ) -> _SSREQ3W { _SSREQ3W { w : self } } # [ doc = "Bit 7 - Destination Request" ] # [ inline ] pub fn dsreq3 ( & mut self ) -> _DSREQ3W { _DSREQ3W { w : self } } # [ doc = "Bit 8 - Source Request" ] # [ inline ] pub fn ssreq4 ( & mut self ) -> _SSREQ4W { _SSREQ4W { w : self } } # [ doc = "Bit 9 - Destination Request" ] # [ inline ] pub fn dsreq4 ( & mut self ) -> _DSREQ4W { _DSREQ4W { w : self } } # [ doc = "Bit 10 - Source Request" ] # [ inline ] pub fn ssreq5 ( & mut self ) -> _SSREQ5W { _SSREQ5W { w : self } } # [ doc = "Bit 11 - Destination Request" ] # [ inline ] pub fn dsreq5 ( & mut self ) -> _DSREQ5W { _DSREQ5W { w : self } } } } # [ doc = "DMAC Software Chunk Transfer Request Register" ] pub struct CREQ { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Software Chunk Transfer Request Register" ] pub mod creq { # [ 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 :: CREQ { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SCREQ0R { bits : bool , } impl SCREQ0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCREQ0R { bits : bool , } impl DCREQ0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCREQ1R { bits : bool , } impl SCREQ1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCREQ1R { bits : bool , } impl DCREQ1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCREQ2R { bits : bool , } impl SCREQ2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCREQ2R { bits : bool , } impl DCREQ2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCREQ3R { bits : bool , } impl SCREQ3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCREQ3R { bits : bool , } impl DCREQ3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCREQ4R { bits : bool , } impl SCREQ4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCREQ4R { bits : bool , } impl DCREQ4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SCREQ5R { bits : bool , } impl SCREQ5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DCREQ5R { bits : bool , } impl DCREQ5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SCREQ0W < 'a > { w : & 'a mut W , } impl < 'a > _SCREQ0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCREQ0W < 'a > { w : & 'a mut W , } impl < 'a > _DCREQ0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCREQ1W < 'a > { w : & 'a mut W , } impl < 'a > _SCREQ1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCREQ1W < 'a > { w : & 'a mut W , } impl < 'a > _DCREQ1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCREQ2W < 'a > { w : & 'a mut W , } impl < 'a > _SCREQ2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCREQ2W < 'a > { w : & 'a mut W , } impl < 'a > _DCREQ2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCREQ3W < 'a > { w : & 'a mut W , } impl < 'a > _SCREQ3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCREQ3W < 'a > { w : & 'a mut W , } impl < 'a > _DCREQ3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCREQ4W < 'a > { w : & 'a mut W , } impl < 'a > _SCREQ4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCREQ4W < 'a > { w : & 'a mut W , } impl < 'a > _DCREQ4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SCREQ5W < 'a > { w : & 'a mut W , } impl < 'a > _SCREQ5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DCREQ5W < 'a > { w : & 'a mut W , } impl < 'a > _DCREQ5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Source Chunk Request" ] # [ inline ] pub fn screq0 ( & self ) -> SCREQ0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCREQ0R { bits } } # [ doc = "Bit 1 - Destination Chunk Request" ] # [ inline ] pub fn dcreq0 ( & self ) -> DCREQ0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCREQ0R { bits } } # [ doc = "Bit 2 - Source Chunk Request" ] # [ inline ] pub fn screq1 ( & self ) -> SCREQ1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCREQ1R { bits } } # [ doc = "Bit 3 - Destination Chunk Request" ] # [ inline ] pub fn dcreq1 ( & self ) -> DCREQ1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCREQ1R { bits } } # [ doc = "Bit 4 - Source Chunk Request" ] # [ inline ] pub fn screq2 ( & self ) -> SCREQ2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCREQ2R { bits } } # [ doc = "Bit 5 - Destination Chunk Request" ] # [ inline ] pub fn dcreq2 ( & self ) -> DCREQ2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCREQ2R { bits } } # [ doc = "Bit 6 - Source Chunk Request" ] # [ inline ] pub fn screq3 ( & self ) -> SCREQ3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCREQ3R { bits } } # [ doc = "Bit 7 - Destination Chunk Request" ] # [ inline ] pub fn dcreq3 ( & self ) -> DCREQ3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCREQ3R { bits } } # [ doc = "Bit 8 - Source Chunk Request" ] # [ inline ] pub fn screq4 ( & self ) -> SCREQ4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCREQ4R { bits } } # [ doc = "Bit 9 - Destination Chunk Request" ] # [ inline ] pub fn dcreq4 ( & self ) -> DCREQ4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCREQ4R { bits } } # [ doc = "Bit 10 - Source Chunk Request" ] # [ inline ] pub fn screq5 ( & self ) -> SCREQ5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCREQ5R { bits } } # [ doc = "Bit 11 - Destination Chunk Request" ] # [ inline ] pub fn dcreq5 ( & self ) -> DCREQ5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DCREQ5R { 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 - Source Chunk Request" ] # [ inline ] pub fn screq0 ( & mut self ) -> _SCREQ0W { _SCREQ0W { w : self } } # [ doc = "Bit 1 - Destination Chunk Request" ] # [ inline ] pub fn dcreq0 ( & mut self ) -> _DCREQ0W { _DCREQ0W { w : self } } # [ doc = "Bit 2 - Source Chunk Request" ] # [ inline ] pub fn screq1 ( & mut self ) -> _SCREQ1W { _SCREQ1W { w : self } } # [ doc = "Bit 3 - Destination Chunk Request" ] # [ inline ] pub fn dcreq1 ( & mut self ) -> _DCREQ1W { _DCREQ1W { w : self } } # [ doc = "Bit 4 - Source Chunk Request" ] # [ inline ] pub fn screq2 ( & mut self ) -> _SCREQ2W { _SCREQ2W { w : self } } # [ doc = "Bit 5 - Destination Chunk Request" ] # [ inline ] pub fn dcreq2 ( & mut self ) -> _DCREQ2W { _DCREQ2W { w : self } } # [ doc = "Bit 6 - Source Chunk Request" ] # [ inline ] pub fn screq3 ( & mut self ) -> _SCREQ3W { _SCREQ3W { w : self } } # [ doc = "Bit 7 - Destination Chunk Request" ] # [ inline ] pub fn dcreq3 ( & mut self ) -> _DCREQ3W { _DCREQ3W { w : self } } # [ doc = "Bit 8 - Source Chunk Request" ] # [ inline ] pub fn screq4 ( & mut self ) -> _SCREQ4W { _SCREQ4W { w : self } } # [ doc = "Bit 9 - Destination Chunk Request" ] # [ inline ] pub fn dcreq4 ( & mut self ) -> _DCREQ4W { _DCREQ4W { w : self } } # [ doc = "Bit 10 - Source Chunk Request" ] # [ inline ] pub fn screq5 ( & mut self ) -> _SCREQ5W { _SCREQ5W { w : self } } # [ doc = "Bit 11 - Destination Chunk Request" ] # [ inline ] pub fn dcreq5 ( & mut self ) -> _DCREQ5W { _DCREQ5W { w : self } } } } # [ doc = "DMAC Software Last Transfer Flag Register" ] pub struct LAST { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Software Last Transfer Flag Register" ] pub mod last { # [ 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 :: LAST { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SLAST0R { bits : bool , } impl SLAST0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLAST0R { bits : bool , } impl DLAST0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLAST1R { bits : bool , } impl SLAST1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLAST1R { bits : bool , } impl DLAST1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLAST2R { bits : bool , } impl SLAST2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLAST2R { bits : bool , } impl DLAST2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLAST3R { bits : bool , } impl SLAST3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLAST3R { bits : bool , } impl DLAST3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLAST4R { bits : bool , } impl SLAST4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLAST4R { bits : bool , } impl DLAST4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SLAST5R { bits : bool , } impl SLAST5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DLAST5R { bits : bool , } impl DLAST5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SLAST0W < 'a > { w : & 'a mut W , } impl < 'a > _SLAST0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLAST0W < 'a > { w : & 'a mut W , } impl < 'a > _DLAST0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLAST1W < 'a > { w : & 'a mut W , } impl < 'a > _SLAST1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLAST1W < 'a > { w : & 'a mut W , } impl < 'a > _DLAST1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLAST2W < 'a > { w : & 'a mut W , } impl < 'a > _SLAST2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLAST2W < 'a > { w : & 'a mut W , } impl < 'a > _DLAST2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLAST3W < 'a > { w : & 'a mut W , } impl < 'a > _SLAST3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLAST3W < 'a > { w : & 'a mut W , } impl < 'a > _DLAST3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLAST4W < 'a > { w : & 'a mut W , } impl < 'a > _SLAST4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLAST4W < 'a > { w : & 'a mut W , } impl < 'a > _DLAST4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLAST5W < 'a > { w : & 'a mut W , } impl < 'a > _SLAST5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DLAST5W < 'a > { w : & 'a mut W , } impl < 'a > _DLAST5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Source Last" ] # [ inline ] pub fn slast0 ( & self ) -> SLAST0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLAST0R { bits } } # [ doc = "Bit 1 - Destination Last" ] # [ inline ] pub fn dlast0 ( & self ) -> DLAST0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLAST0R { bits } } # [ doc = "Bit 2 - Source Last" ] # [ inline ] pub fn slast1 ( & self ) -> SLAST1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLAST1R { bits } } # [ doc = "Bit 3 - Destination Last" ] # [ inline ] pub fn dlast1 ( & self ) -> DLAST1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLAST1R { bits } } # [ doc = "Bit 4 - Source Last" ] # [ inline ] pub fn slast2 ( & self ) -> SLAST2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLAST2R { bits } } # [ doc = "Bit 5 - Destination Last" ] # [ inline ] pub fn dlast2 ( & self ) -> DLAST2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLAST2R { bits } } # [ doc = "Bit 6 - Source Last" ] # [ inline ] pub fn slast3 ( & self ) -> SLAST3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLAST3R { bits } } # [ doc = "Bit 7 - Destination Last" ] # [ inline ] pub fn dlast3 ( & self ) -> DLAST3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLAST3R { bits } } # [ doc = "Bit 8 - Source Last" ] # [ inline ] pub fn slast4 ( & self ) -> SLAST4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLAST4R { bits } } # [ doc = "Bit 9 - Destination Last" ] # [ inline ] pub fn dlast4 ( & self ) -> DLAST4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLAST4R { bits } } # [ doc = "Bit 10 - Source Last" ] # [ inline ] pub fn slast5 ( & self ) -> SLAST5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLAST5R { bits } } # [ doc = "Bit 11 - Destination Last" ] # [ inline ] pub fn dlast5 ( & self ) -> DLAST5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DLAST5R { 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 - Source Last" ] # [ inline ] pub fn slast0 ( & mut self ) -> _SLAST0W { _SLAST0W { w : self } } # [ doc = "Bit 1 - Destination Last" ] # [ inline ] pub fn dlast0 ( & mut self ) -> _DLAST0W { _DLAST0W { w : self } } # [ doc = "Bit 2 - Source Last" ] # [ inline ] pub fn slast1 ( & mut self ) -> _SLAST1W { _SLAST1W { w : self } } # [ doc = "Bit 3 - Destination Last" ] # [ inline ] pub fn dlast1 ( & mut self ) -> _DLAST1W { _DLAST1W { w : self } } # [ doc = "Bit 4 - Source Last" ] # [ inline ] pub fn slast2 ( & mut self ) -> _SLAST2W { _SLAST2W { w : self } } # [ doc = "Bit 5 - Destination Last" ] # [ inline ] pub fn dlast2 ( & mut self ) -> _DLAST2W { _DLAST2W { w : self } } # [ doc = "Bit 6 - Source Last" ] # [ inline ] pub fn slast3 ( & mut self ) -> _SLAST3W { _SLAST3W { w : self } } # [ doc = "Bit 7 - Destination Last" ] # [ inline ] pub fn dlast3 ( & mut self ) -> _DLAST3W { _DLAST3W { w : self } } # [ doc = "Bit 8 - Source Last" ] # [ inline ] pub fn slast4 ( & mut self ) -> _SLAST4W { _SLAST4W { w : self } } # [ doc = "Bit 9 - Destination Last" ] # [ inline ] pub fn dlast4 ( & mut self ) -> _DLAST4W { _DLAST4W { w : self } } # [ doc = "Bit 10 - Source Last" ] # [ inline ] pub fn slast5 ( & mut self ) -> _SLAST5W { _SLAST5W { w : self } } # [ doc = "Bit 11 - Destination Last" ] # [ inline ] pub fn dlast5 ( & mut self ) -> _DLAST5W { _DLAST5W { w : self } } } } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Enable register." ] pub struct EBCIER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Enable register." ] pub mod ebcier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: EBCIER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _BTC0W < 'a > { w : & 'a mut W , } impl < 'a > _BTC0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC1W < 'a > { w : & 'a mut W , } impl < 'a > _BTC1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC2W < 'a > { w : & 'a mut W , } impl < 'a > _BTC2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC3W < 'a > { w : & 'a mut W , } impl < 'a > _BTC3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC4W < 'a > { w : & 'a mut W , } impl < 'a > _BTC4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC5W < 'a > { w : & 'a mut W , } impl < 'a > _BTC5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC0W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC1W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC2W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC3W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC4W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC5W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR0W < 'a > { w : & 'a mut W , } impl < 'a > _ERR0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR1W < 'a > { w : & 'a mut W , } impl < 'a > _ERR1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR2W < 'a > { w : & 'a mut W , } impl < 'a > _ERR2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR3W < 'a > { w : & 'a mut W , } impl < 'a > _ERR3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR4W < 'a > { w : & 'a mut W , } impl < 'a > _ERR4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR5W < 'a > { w : & 'a mut W , } impl < 'a > _ERR5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc0 ( & mut self ) -> _BTC0W { _BTC0W { w : self } } # [ doc = "Bit 1 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc1 ( & mut self ) -> _BTC1W { _BTC1W { w : self } } # [ doc = "Bit 2 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc2 ( & mut self ) -> _BTC2W { _BTC2W { w : self } } # [ doc = "Bit 3 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc3 ( & mut self ) -> _BTC3W { _BTC3W { w : self } } # [ doc = "Bit 4 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc4 ( & mut self ) -> _BTC4W { _BTC4W { w : self } } # [ doc = "Bit 5 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc5 ( & mut self ) -> _BTC5W { _BTC5W { w : self } } # [ doc = "Bit 8 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc0 ( & mut self ) -> _CBTC0W { _CBTC0W { w : self } } # [ doc = "Bit 9 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc1 ( & mut self ) -> _CBTC1W { _CBTC1W { w : self } } # [ doc = "Bit 10 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc2 ( & mut self ) -> _CBTC2W { _CBTC2W { w : self } } # [ doc = "Bit 11 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc3 ( & mut self ) -> _CBTC3W { _CBTC3W { w : self } } # [ doc = "Bit 12 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc4 ( & mut self ) -> _CBTC4W { _CBTC4W { w : self } } # [ doc = "Bit 13 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc5 ( & mut self ) -> _CBTC5W { _CBTC5W { w : self } } # [ doc = "Bit 16 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err0 ( & mut self ) -> _ERR0W { _ERR0W { w : self } } # [ doc = "Bit 17 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err1 ( & mut self ) -> _ERR1W { _ERR1W { w : self } } # [ doc = "Bit 18 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err2 ( & mut self ) -> _ERR2W { _ERR2W { w : self } } # [ doc = "Bit 19 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err3 ( & mut self ) -> _ERR3W { _ERR3W { w : self } } # [ doc = "Bit 20 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err4 ( & mut self ) -> _ERR4W { _ERR4W { w : self } } # [ doc = "Bit 21 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err5 ( & mut self ) -> _ERR5W { _ERR5W { w : self } } } } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Disable register." ] pub struct EBCIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Disable register." ] pub mod ebcidr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: EBCIDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _BTC0W < 'a > { w : & 'a mut W , } impl < 'a > _BTC0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC1W < 'a > { w : & 'a mut W , } impl < 'a > _BTC1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC2W < 'a > { w : & 'a mut W , } impl < 'a > _BTC2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC3W < 'a > { w : & 'a mut W , } impl < 'a > _BTC3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC4W < 'a > { w : & 'a mut W , } impl < 'a > _BTC4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _BTC5W < 'a > { w : & 'a mut W , } impl < 'a > _BTC5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC0W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC1W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC2W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC3W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC4W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CBTC5W < 'a > { w : & 'a mut W , } impl < 'a > _CBTC5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR0W < 'a > { w : & 'a mut W , } impl < 'a > _ERR0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR1W < 'a > { w : & 'a mut W , } impl < 'a > _ERR1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR2W < 'a > { w : & 'a mut W , } impl < 'a > _ERR2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR3W < 'a > { w : & 'a mut W , } impl < 'a > _ERR3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR4W < 'a > { w : & 'a mut W , } impl < 'a > _ERR4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERR5W < 'a > { w : & 'a mut W , } impl < 'a > _ERR5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc0 ( & mut self ) -> _BTC0W { _BTC0W { w : self } } # [ doc = "Bit 1 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc1 ( & mut self ) -> _BTC1W { _BTC1W { w : self } } # [ doc = "Bit 2 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc2 ( & mut self ) -> _BTC2W { _BTC2W { w : self } } # [ doc = "Bit 3 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc3 ( & mut self ) -> _BTC3W { _BTC3W { w : self } } # [ doc = "Bit 4 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc4 ( & mut self ) -> _BTC4W { _BTC4W { w : self } } # [ doc = "Bit 5 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc5 ( & mut self ) -> _BTC5W { _BTC5W { w : self } } # [ doc = "Bit 8 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc0 ( & mut self ) -> _CBTC0W { _CBTC0W { w : self } } # [ doc = "Bit 9 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc1 ( & mut self ) -> _CBTC1W { _CBTC1W { w : self } } # [ doc = "Bit 10 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc2 ( & mut self ) -> _CBTC2W { _CBTC2W { w : self } } # [ doc = "Bit 11 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc3 ( & mut self ) -> _CBTC3W { _CBTC3W { w : self } } # [ doc = "Bit 12 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc4 ( & mut self ) -> _CBTC4W { _CBTC4W { w : self } } # [ doc = "Bit 13 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc5 ( & mut self ) -> _CBTC5W { _CBTC5W { w : self } } # [ doc = "Bit 16 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err0 ( & mut self ) -> _ERR0W { _ERR0W { w : self } } # [ doc = "Bit 17 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err1 ( & mut self ) -> _ERR1W { _ERR1W { w : self } } # [ doc = "Bit 18 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err2 ( & mut self ) -> _ERR2W { _ERR2W { w : self } } # [ doc = "Bit 19 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err3 ( & mut self ) -> _ERR3W { _ERR3W { w : self } } # [ doc = "Bit 20 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err4 ( & mut self ) -> _ERR4W { _ERR4W { w : self } } # [ doc = "Bit 21 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err5 ( & mut self ) -> _ERR5W { _ERR5W { w : self } } } } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Mask Register." ] pub struct EBCIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Mask Register." ] pub mod ebcimr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: EBCIMR { # [ 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 BTC0R { bits : bool , } impl BTC0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC1R { bits : bool , } impl BTC1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC2R { bits : bool , } impl BTC2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC3R { bits : bool , } impl BTC3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC4R { bits : bool , } impl BTC4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC5R { bits : bool , } impl BTC5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC0R { bits : bool , } impl CBTC0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC1R { bits : bool , } impl CBTC1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC2R { bits : bool , } impl CBTC2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC3R { bits : bool , } impl CBTC3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC4R { bits : bool , } impl CBTC4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC5R { bits : bool , } impl CBTC5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR0R { bits : bool , } impl ERR0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR1R { bits : bool , } impl ERR1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR2R { bits : bool , } impl ERR2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR3R { bits : bool , } impl ERR3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR4R { bits : bool , } impl ERR4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR5R { bits : bool , } impl ERR5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc0 ( & self ) -> BTC0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC0R { bits } } # [ doc = "Bit 1 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc1 ( & self ) -> BTC1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC1R { bits } } # [ doc = "Bit 2 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc2 ( & self ) -> BTC2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC2R { bits } } # [ doc = "Bit 3 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc3 ( & self ) -> BTC3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC3R { bits } } # [ doc = "Bit 4 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc4 ( & self ) -> BTC4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC4R { bits } } # [ doc = "Bit 5 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc5 ( & self ) -> BTC5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC5R { bits } } # [ doc = "Bit 8 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc0 ( & self ) -> CBTC0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC0R { bits } } # [ doc = "Bit 9 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc1 ( & self ) -> CBTC1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC1R { bits } } # [ doc = "Bit 10 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc2 ( & self ) -> CBTC2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC2R { bits } } # [ doc = "Bit 11 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc3 ( & self ) -> CBTC3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC3R { bits } } # [ doc = "Bit 12 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc4 ( & self ) -> CBTC4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC4R { bits } } # [ doc = "Bit 13 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc5 ( & self ) -> CBTC5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC5R { bits } } # [ doc = "Bit 16 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err0 ( & self ) -> ERR0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR0R { bits } } # [ doc = "Bit 17 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err1 ( & self ) -> ERR1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR1R { bits } } # [ doc = "Bit 18 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err2 ( & self ) -> ERR2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR2R { bits } } # [ doc = "Bit 19 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err3 ( & self ) -> ERR3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR3R { bits } } # [ doc = "Bit 20 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err4 ( & self ) -> ERR4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR4R { bits } } # [ doc = "Bit 21 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err5 ( & self ) -> ERR5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR5R { bits } } } } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Status Register." ] pub struct EBCISR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Status Register." ] pub mod ebcisr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: EBCISR { # [ 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 BTC0R { bits : bool , } impl BTC0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC1R { bits : bool , } impl BTC1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC2R { bits : bool , } impl BTC2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC3R { bits : bool , } impl BTC3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC4R { bits : bool , } impl BTC4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct BTC5R { bits : bool , } impl BTC5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC0R { bits : bool , } impl CBTC0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC1R { bits : bool , } impl CBTC1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC2R { bits : bool , } impl CBTC2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC3R { bits : bool , } impl CBTC3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC4R { bits : bool , } impl CBTC4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CBTC5R { bits : bool , } impl CBTC5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR0R { bits : bool , } impl ERR0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR1R { bits : bool , } impl ERR1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR2R { bits : bool , } impl ERR2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR3R { bits : bool , } impl ERR3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR4R { bits : bool , } impl ERR4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERR5R { bits : bool , } impl ERR5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc0 ( & self ) -> BTC0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC0R { bits } } # [ doc = "Bit 1 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc1 ( & self ) -> BTC1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC1R { bits } } # [ doc = "Bit 2 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc2 ( & self ) -> BTC2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC2R { bits } } # [ doc = "Bit 3 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc3 ( & self ) -> BTC3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC3R { bits } } # [ doc = "Bit 4 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc4 ( & self ) -> BTC4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC4R { bits } } # [ doc = "Bit 5 - Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn btc5 ( & self ) -> BTC5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BTC5R { bits } } # [ doc = "Bit 8 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc0 ( & self ) -> CBTC0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC0R { bits } } # [ doc = "Bit 9 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc1 ( & self ) -> CBTC1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC1R { bits } } # [ doc = "Bit 10 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc2 ( & self ) -> CBTC2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC2R { bits } } # [ doc = "Bit 11 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc3 ( & self ) -> CBTC3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC3R { bits } } # [ doc = "Bit 12 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc4 ( & self ) -> CBTC4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC4R { bits } } # [ doc = "Bit 13 - Chained Buffer Transfer Completed \\[5:0\\]" ] # [ inline ] pub fn cbtc5 ( & self ) -> CBTC5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CBTC5R { bits } } # [ doc = "Bit 16 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err0 ( & self ) -> ERR0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR0R { bits } } # [ doc = "Bit 17 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err1 ( & self ) -> ERR1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR1R { bits } } # [ doc = "Bit 18 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err2 ( & self ) -> ERR2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR2R { bits } } # [ doc = "Bit 19 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err3 ( & self ) -> ERR3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR3R { bits } } # [ doc = "Bit 20 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err4 ( & self ) -> ERR4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR4R { bits } } # [ doc = "Bit 21 - Access Error \\[5:0\\]" ] # [ inline ] pub fn err5 ( & self ) -> ERR5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ERR5R { bits } } } } # [ doc = "DMAC Channel Handler Enable Register" ] pub struct CHER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Handler Enable Register" ] pub mod cher { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CHER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _ENA0W < 'a > { w : & 'a mut W , } impl < 'a > _ENA0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENA1W < 'a > { w : & 'a mut W , } impl < 'a > _ENA1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENA2W < 'a > { w : & 'a mut W , } impl < 'a > _ENA2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENA3W < 'a > { w : & 'a mut W , } impl < 'a > _ENA3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENA4W < 'a > { w : & 'a mut W , } impl < 'a > _ENA4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENA5W < 'a > { w : & 'a mut W , } impl < 'a > _ENA5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SUSP0W < 'a > { w : & 'a mut W , } impl < 'a > _SUSP0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SUSP1W < 'a > { w : & 'a mut W , } impl < 'a > _SUSP1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SUSP2W < 'a > { w : & 'a mut W , } impl < 'a > _SUSP2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SUSP3W < 'a > { w : & 'a mut W , } impl < 'a > _SUSP3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SUSP4W < 'a > { w : & 'a mut W , } impl < 'a > _SUSP4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SUSP5W < 'a > { w : & 'a mut W , } impl < 'a > _SUSP5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KEEP0W < 'a > { w : & 'a mut W , } impl < 'a > _KEEP0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KEEP1W < 'a > { w : & 'a mut W , } impl < 'a > _KEEP1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KEEP2W < 'a > { w : & 'a mut W , } impl < 'a > _KEEP2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KEEP3W < 'a > { w : & 'a mut W , } impl < 'a > _KEEP3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KEEP4W < 'a > { w : & 'a mut W , } impl < 'a > _KEEP4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _KEEP5W < 'a > { w : & 'a mut W , } impl < 'a > _KEEP5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena0 ( & mut self ) -> _ENA0W { _ENA0W { w : self } } # [ doc = "Bit 1 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena1 ( & mut self ) -> _ENA1W { _ENA1W { w : self } } # [ doc = "Bit 2 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena2 ( & mut self ) -> _ENA2W { _ENA2W { w : self } } # [ doc = "Bit 3 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena3 ( & mut self ) -> _ENA3W { _ENA3W { w : self } } # [ doc = "Bit 4 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena4 ( & mut self ) -> _ENA4W { _ENA4W { w : self } } # [ doc = "Bit 5 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena5 ( & mut self ) -> _ENA5W { _ENA5W { w : self } } # [ doc = "Bit 8 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp0 ( & mut self ) -> _SUSP0W { _SUSP0W { w : self } } # [ doc = "Bit 9 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp1 ( & mut self ) -> _SUSP1W { _SUSP1W { w : self } } # [ doc = "Bit 10 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp2 ( & mut self ) -> _SUSP2W { _SUSP2W { w : self } } # [ doc = "Bit 11 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp3 ( & mut self ) -> _SUSP3W { _SUSP3W { w : self } } # [ doc = "Bit 12 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp4 ( & mut self ) -> _SUSP4W { _SUSP4W { w : self } } # [ doc = "Bit 13 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp5 ( & mut self ) -> _SUSP5W { _SUSP5W { w : self } } # [ doc = "Bit 24 - Keep on \\[5:0\\]" ] # [ inline ] pub fn keep0 ( & mut self ) -> _KEEP0W { _KEEP0W { w : self } } # [ doc = "Bit 25 - Keep on \\[5:0\\]" ] # [ inline ] pub fn keep1 ( & mut self ) -> _KEEP1W { _KEEP1W { w : self } } # [ doc = "Bit 26 - Keep on \\[5:0\\]" ] # [ inline ] pub fn keep2 ( & mut self ) -> _KEEP2W { _KEEP2W { w : self } } # [ doc = "Bit 27 - Keep on \\[5:0\\]" ] # [ inline ] pub fn keep3 ( & mut self ) -> _KEEP3W { _KEEP3W { w : self } } # [ doc = "Bit 28 - Keep on \\[5:0\\]" ] # [ inline ] pub fn keep4 ( & mut self ) -> _KEEP4W { _KEEP4W { w : self } } # [ doc = "Bit 29 - Keep on \\[5:0\\]" ] # [ inline ] pub fn keep5 ( & mut self ) -> _KEEP5W { _KEEP5W { w : self } } } } # [ doc = "DMAC Channel Handler Disable Register" ] pub struct CHDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Handler Disable Register" ] pub mod chdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CHDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _DIS0W < 'a > { w : & 'a mut W , } impl < 'a > _DIS0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIS1W < 'a > { w : & 'a mut W , } impl < 'a > _DIS1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIS2W < 'a > { w : & 'a mut W , } impl < 'a > _DIS2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIS3W < 'a > { w : & 'a mut W , } impl < 'a > _DIS3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIS4W < 'a > { w : & 'a mut W , } impl < 'a > _DIS4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DIS5W < 'a > { w : & 'a mut W , } impl < 'a > _DIS5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RES0W < 'a > { w : & 'a mut W , } impl < 'a > _RES0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RES1W < 'a > { w : & 'a mut W , } impl < 'a > _RES1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RES2W < 'a > { w : & 'a mut W , } impl < 'a > _RES2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RES3W < 'a > { w : & 'a mut W , } impl < 'a > _RES3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RES4W < 'a > { w : & 'a mut W , } impl < 'a > _RES4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RES5W < 'a > { w : & 'a mut W , } impl < 'a > _RES5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Disable \\[5:0\\]" ] # [ inline ] pub fn dis0 ( & mut self ) -> _DIS0W { _DIS0W { w : self } } # [ doc = "Bit 1 - Disable \\[5:0\\]" ] # [ inline ] pub fn dis1 ( & mut self ) -> _DIS1W { _DIS1W { w : self } } # [ doc = "Bit 2 - Disable \\[5:0\\]" ] # [ inline ] pub fn dis2 ( & mut self ) -> _DIS2W { _DIS2W { w : self } } # [ doc = "Bit 3 - Disable \\[5:0\\]" ] # [ inline ] pub fn dis3 ( & mut self ) -> _DIS3W { _DIS3W { w : self } } # [ doc = "Bit 4 - Disable \\[5:0\\]" ] # [ inline ] pub fn dis4 ( & mut self ) -> _DIS4W { _DIS4W { w : self } } # [ doc = "Bit 5 - Disable \\[5:0\\]" ] # [ inline ] pub fn dis5 ( & mut self ) -> _DIS5W { _DIS5W { w : self } } # [ doc = "Bit 8 - Resume \\[5:0\\]" ] # [ inline ] pub fn res0 ( & mut self ) -> _RES0W { _RES0W { w : self } } # [ doc = "Bit 9 - Resume \\[5:0\\]" ] # [ inline ] pub fn res1 ( & mut self ) -> _RES1W { _RES1W { w : self } } # [ doc = "Bit 10 - Resume \\[5:0\\]" ] # [ inline ] pub fn res2 ( & mut self ) -> _RES2W { _RES2W { w : self } } # [ doc = "Bit 11 - Resume \\[5:0\\]" ] # [ inline ] pub fn res3 ( & mut self ) -> _RES3W { _RES3W { w : self } } # [ doc = "Bit 12 - Resume \\[5:0\\]" ] # [ inline ] pub fn res4 ( & mut self ) -> _RES4W { _RES4W { w : self } } # [ doc = "Bit 13 - Resume \\[5:0\\]" ] # [ inline ] pub fn res5 ( & mut self ) -> _RES5W { _RES5W { w : self } } } } # [ doc = "DMAC Channel Handler Status Register" ] pub struct CHSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Handler Status Register" ] pub mod chsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CHSR { # [ 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 ENA0R { bits : bool , } impl ENA0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENA1R { bits : bool , } impl ENA1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENA2R { bits : bool , } impl ENA2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENA3R { bits : bool , } impl ENA3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENA4R { bits : bool , } impl ENA4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENA5R { bits : bool , } impl ENA5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SUSP0R { bits : bool , } impl SUSP0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SUSP1R { bits : bool , } impl SUSP1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SUSP2R { bits : bool , } impl SUSP2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SUSP3R { bits : bool , } impl SUSP3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SUSP4R { bits : bool , } impl SUSP4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SUSP5R { bits : bool , } impl SUSP5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EMPT0R { bits : bool , } impl EMPT0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EMPT1R { bits : bool , } impl EMPT1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EMPT2R { bits : bool , } impl EMPT2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EMPT3R { bits : bool , } impl EMPT3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EMPT4R { bits : bool , } impl EMPT4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EMPT5R { bits : bool , } impl EMPT5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STAL0R { bits : bool , } impl STAL0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STAL1R { bits : bool , } impl STAL1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STAL2R { bits : bool , } impl STAL2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STAL3R { bits : bool , } impl STAL3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STAL4R { bits : bool , } impl STAL4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct STAL5R { bits : bool , } impl STAL5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena0 ( & self ) -> ENA0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENA0R { bits } } # [ doc = "Bit 1 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena1 ( & self ) -> ENA1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENA1R { bits } } # [ doc = "Bit 2 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena2 ( & self ) -> ENA2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENA2R { bits } } # [ doc = "Bit 3 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena3 ( & self ) -> ENA3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENA3R { bits } } # [ doc = "Bit 4 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena4 ( & self ) -> ENA4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENA4R { bits } } # [ doc = "Bit 5 - Enable \\[5:0\\]" ] # [ inline ] pub fn ena5 ( & self ) -> ENA5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENA5R { bits } } # [ doc = "Bit 8 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp0 ( & self ) -> SUSP0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSP0R { bits } } # [ doc = "Bit 9 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp1 ( & self ) -> SUSP1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSP1R { bits } } # [ doc = "Bit 10 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp2 ( & self ) -> SUSP2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSP2R { bits } } # [ doc = "Bit 11 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp3 ( & self ) -> SUSP3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSP3R { bits } } # [ doc = "Bit 12 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp4 ( & self ) -> SUSP4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSP4R { bits } } # [ doc = "Bit 13 - Suspend \\[5:0\\]" ] # [ inline ] pub fn susp5 ( & self ) -> SUSP5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SUSP5R { bits } } # [ doc = "Bit 16 - Empty \\[5:0\\]" ] # [ inline ] pub fn empt0 ( & self ) -> EMPT0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EMPT0R { bits } } # [ doc = "Bit 17 - Empty \\[5:0\\]" ] # [ inline ] pub fn empt1 ( & self ) -> EMPT1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EMPT1R { bits } } # [ doc = "Bit 18 - Empty \\[5:0\\]" ] # [ inline ] pub fn empt2 ( & self ) -> EMPT2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EMPT2R { bits } } # [ doc = "Bit 19 - Empty \\[5:0\\]" ] # [ inline ] pub fn empt3 ( & self ) -> EMPT3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EMPT3R { bits } } # [ doc = "Bit 20 - Empty \\[5:0\\]" ] # [ inline ] pub fn empt4 ( & self ) -> EMPT4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EMPT4R { bits } } # [ doc = "Bit 21 - Empty \\[5:0\\]" ] # [ inline ] pub fn empt5 ( & self ) -> EMPT5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EMPT5R { bits } } # [ doc = "Bit 24 - Stalled \\[5:0\\]" ] # [ inline ] pub fn stal0 ( & self ) -> STAL0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STAL0R { bits } } # [ doc = "Bit 25 - Stalled \\[5:0\\]" ] # [ inline ] pub fn stal1 ( & self ) -> STAL1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STAL1R { bits } } # [ doc = "Bit 26 - Stalled \\[5:0\\]" ] # [ inline ] pub fn stal2 ( & self ) -> STAL2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STAL2R { bits } } # [ doc = "Bit 27 - Stalled \\[5:0\\]" ] # [ inline ] pub fn stal3 ( & self ) -> STAL3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STAL3R { bits } } # [ doc = "Bit 28 - Stalled \\[5:0\\]" ] # [ inline ] pub fn stal4 ( & self ) -> STAL4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STAL4R { bits } } # [ doc = "Bit 29 - Stalled \\[5:0\\]" ] # [ inline ] pub fn stal5 ( & self ) -> STAL5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; STAL5R { bits } } } } # [ doc = "DMAC Channel Source Address Register (ch_num = 0)" ] pub struct SADDR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Source Address Register (ch_num = 0)" ] pub mod saddr0 { # [ 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 :: SADDR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADDRR { bits : u32 , } impl SADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADDRW < 'a > { w : & 'a mut W , } impl < 'a > _SADDRW < '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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & self ) -> SADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; SADDRR { 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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & mut self ) -> _SADDRW { _SADDRW { w : self } } } } # [ doc = "DMAC Channel Destination Address Register (ch_num = 0)" ] pub struct DADDR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Destination Address Register (ch_num = 0)" ] pub mod daddr0 { # [ 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 :: DADDR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DADDRR { bits : u32 , } impl DADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DADDRW < 'a > { w : & 'a mut W , } impl < 'a > _DADDRW < '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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & self ) -> DADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DADDRR { 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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & mut self ) -> _DADDRW { _DADDRW { w : self } } } } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 0)" ] pub struct DSCR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 0)" ] pub mod dscr0 { # [ 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 :: DSCR0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DSCRR { bits : u32 , } impl DSCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DSCRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & self ) -> DSCRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DSCRR { 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 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & mut self ) -> _DSCRW { _DSCRW { w : self } } } } # [ doc = "DMAC Channel Control A Register (ch_num = 0)" ] pub struct CTRLA0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control A Register (ch_num = 0)" ] pub mod ctrla0 { # [ 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 :: CTRLA0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BTSIZER { bits : u16 , } impl BTSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = "Possible values of the field `SCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SCSIZER :: CHK_1 => 0 , SCSIZER :: CHK_4 => 0x01 , SCSIZER :: CHK_8 => 0x02 , SCSIZER :: CHK_16 => 0x03 , SCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SCSIZER { match value { 0 => SCSIZER :: CHK_1 , 1 => SCSIZER :: CHK_4 , 2 => SCSIZER :: CHK_8 , 3 => SCSIZER :: CHK_16 , i => SCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == SCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == SCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == SCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == SCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `DCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DCSIZER :: CHK_1 => 0 , DCSIZER :: CHK_4 => 0x01 , DCSIZER :: CHK_8 => 0x02 , DCSIZER :: CHK_16 => 0x03 , DCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DCSIZER { match value { 0 => DCSIZER :: CHK_1 , 1 => DCSIZER :: CHK_4 , 2 => DCSIZER :: CHK_8 , 3 => DCSIZER :: CHK_16 , i => DCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == DCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == DCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == DCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == DCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `SRC_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_WIDTHR :: BYTE => 0 , SRC_WIDTHR :: HALF_WORD => 0x01 , SRC_WIDTHR :: WORD => 0x02 , SRC_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_WIDTHR { match value { 0 => SRC_WIDTHR :: BYTE , 1 => SRC_WIDTHR :: HALF_WORD , 2 => SRC_WIDTHR :: WORD , i => SRC_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == SRC_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == SRC_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == SRC_WIDTHR :: WORD } } # [ doc = "Possible values of the field `DST_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_WIDTHR :: BYTE => 0 , DST_WIDTHR :: HALF_WORD => 0x01 , DST_WIDTHR :: WORD => 0x02 , DST_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_WIDTHR { match value { 0 => DST_WIDTHR :: BYTE , 1 => DST_WIDTHR :: HALF_WORD , 2 => DST_WIDTHR :: WORD , i => DST_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == DST_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == DST_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == DST_WIDTHR :: WORD } } # [ doc = r" Value of the field" ] pub struct DONER { bits : bool , } impl DONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _BTSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _BTSIZEW < '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 } } # [ doc = "Values that can be written to the field `SCSIZE`" ] pub enum SCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl SCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SCSIZEW :: CHK_1 => 0 , SCSIZEW :: CHK_4 => 1 , SCSIZEW :: CHK_8 => 2 , SCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _SCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _SCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_16 ) } # [ 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `DCSIZE`" ] pub enum DCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl DCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DCSIZEW :: CHK_1 => 0 , DCSIZEW :: CHK_4 => 1 , DCSIZEW :: CHK_8 => 2 , DCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _DCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _DCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_16 ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `SRC_WIDTH`" ] pub enum SRC_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl SRC_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_WIDTHW :: BYTE => 0 , SRC_WIDTHW :: HALF_WORD => 1 , SRC_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: WORD ) } # [ 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 = "Values that can be written to the field `DST_WIDTH`" ] pub enum DST_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl DST_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_WIDTHW :: BYTE => 0 , DST_WIDTHW :: HALF_WORD => 1 , DST_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _DST_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: WORD ) } # [ 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 _DONEW < 'a > { w : & 'a mut W , } impl < 'a > _DONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:15 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & self ) -> BTSIZER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BTSIZER { bits } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & self ) -> SCSIZER { SCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & self ) -> DCSIZER { DCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & self ) -> SRC_WIDTHR { SRC_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & self ) -> DST_WIDTHR { DST_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & self ) -> DONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DONER { 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 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & mut self ) -> _BTSIZEW { _BTSIZEW { w : self } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & mut self ) -> _SCSIZEW { _SCSIZEW { w : self } } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & mut self ) -> _DCSIZEW { _DCSIZEW { w : self } } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & mut self ) -> _SRC_WIDTHW { _SRC_WIDTHW { w : self } } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & mut self ) -> _DST_WIDTHW { _DST_WIDTHW { w : self } } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & mut self ) -> _DONEW { _DONEW { w : self } } } } # [ doc = "DMAC Channel Control B Register (ch_num = 0)" ] pub struct CTRLB0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control B Register (ch_num = 0)" ] pub mod ctrlb0 { # [ 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 :: CTRLB0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `SRC_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_DSCRR { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_DSCRR :: FETCH_FROM_MEM => false , SRC_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_DSCRR { match value { false => SRC_DSCRR :: FETCH_FROM_MEM , true => SRC_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `DST_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_DSCRR { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_DSCRR :: FETCH_FROM_MEM => false , DST_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_DSCRR { match value { false => DST_DSCRR :: FETCH_FROM_MEM , true => DST_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == DST_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == DST_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `FC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FCR { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FCR :: MEM2MEM_DMA_FC => 0 , FCR :: MEM2PER_DMA_FC => 0x01 , FCR :: PER2MEM_DMA_FC => 0x02 , FCR :: PER2PER_DMA_FC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FCR { match value { 0 => FCR :: MEM2MEM_DMA_FC , 1 => FCR :: MEM2PER_DMA_FC , 2 => FCR :: PER2MEM_DMA_FC , 3 => FCR :: PER2PER_DMA_FC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MEM2MEM_DMA_FC`" ] # [ inline ] pub fn is_mem2mem_dma_fc ( & self ) -> bool { * self == FCR :: MEM2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `MEM2PER_DMA_FC`" ] # [ inline ] pub fn is_mem2per_dma_fc ( & self ) -> bool { * self == FCR :: MEM2PER_DMA_FC } # [ doc = "Checks if the value of the field is `PER2MEM_DMA_FC`" ] # [ inline ] pub fn is_per2mem_dma_fc ( & self ) -> bool { * self == FCR :: PER2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `PER2PER_DMA_FC`" ] # [ inline ] pub fn is_per2per_dma_fc ( & self ) -> bool { * self == FCR :: PER2PER_DMA_FC } } # [ doc = "Possible values of the field `SRC_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_INCRR { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_INCRR :: INCREMENTING => 0 , SRC_INCRR :: DECREMENTING => 0x01 , SRC_INCRR :: FIXED => 0x02 , SRC_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_INCRR { match value { 0 => SRC_INCRR :: INCREMENTING , 1 => SRC_INCRR :: DECREMENTING , 2 => SRC_INCRR :: FIXED , i => SRC_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == SRC_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == SRC_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == SRC_INCRR :: FIXED } } # [ doc = "Possible values of the field `DST_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_INCRR { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_INCRR :: INCREMENTING => 0 , DST_INCRR :: DECREMENTING => 0x01 , DST_INCRR :: FIXED => 0x02 , DST_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_INCRR { match value { 0 => DST_INCRR :: INCREMENTING , 1 => DST_INCRR :: DECREMENTING , 2 => DST_INCRR :: FIXED , i => DST_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == DST_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == DST_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == DST_INCRR :: FIXED } } # [ doc = r" Value of the field" ] pub struct IENR { bits : bool , } impl IENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `SRC_DSCR`" ] pub enum SRC_DSCRW { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_DSCRW :: FETCH_FROM_MEM => false , SRC_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _SRC_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_DSCR`" ] pub enum DST_DSCRW { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_DSCRW :: FETCH_FROM_MEM => false , DST_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _DST_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FC`" ] pub enum FCW { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCW :: MEM2MEM_DMA_FC => 0 , FCW :: MEM2PER_DMA_FC => 1 , FCW :: PER2MEM_DMA_FC => 2 , FCW :: PER2PER_DMA_FC => 3 } } } # [ doc = r" Proxy" ] pub struct _FCW < 'a > { w : & 'a mut W , } impl < 'a > _FCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2MEM_DMA_FC ) } # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2PER_DMA_FC ) } # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn per2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2MEM_DMA_FC ) } # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn per2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2PER_DMA_FC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SRC_INCR`" ] pub enum SRC_INCRW { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED } impl SRC_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_INCRW :: INCREMENTING => 0 , SRC_INCRW :: DECREMENTING => 1 , SRC_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The source address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: INCREMENTING ) } # [ doc = "The source address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: DECREMENTING ) } # [ doc = "The source address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: FIXED ) } # [ 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 = "Values that can be written to the field `DST_INCR`" ] pub enum DST_INCRW { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED } impl DST_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_INCRW :: INCREMENTING => 0 , DST_INCRW :: DECREMENTING => 1 , DST_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The destination address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: INCREMENTING ) } # [ doc = "The destination address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: DECREMENTING ) } # [ doc = "The destination address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: FIXED ) } # [ 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 _IENW < 'a > { w : & 'a mut W , } impl < 'a > _IENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 16 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & self ) -> SRC_DSCRR { SRC_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & self ) -> DST_DSCRR { DST_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & self ) -> FCR { FCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & self ) -> SRC_INCRR { SRC_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & self ) -> DST_INCRR { DST_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & self ) -> IENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IENR { 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 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & mut self ) -> _SRC_DSCRW { _SRC_DSCRW { w : self } } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & mut self ) -> _DST_DSCRW { _DST_DSCRW { w : self } } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & mut self ) -> _FCW { _FCW { w : self } } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & mut self ) -> _SRC_INCRW { _SRC_INCRW { w : self } } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & mut self ) -> _DST_INCRW { _DST_INCRW { w : self } } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & mut self ) -> _IENW { _IENW { w : self } } } } # [ doc = "DMAC Channel Configuration Register (ch_num = 0)" ] pub struct CFG0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Configuration Register (ch_num = 0)" ] pub mod cfg0 { # [ 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 :: CFG0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SRC_PERR { bits : u8 , } impl SRC_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DST_PERR { bits : u8 , } impl DST_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SRC_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_H2SELR :: SW => false , SRC_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_H2SELR { match value { false => SRC_H2SELR :: SW , true => SRC_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == SRC_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == SRC_H2SELR :: HW } } # [ doc = "Possible values of the field `DST_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_H2SELR :: SW => false , DST_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_H2SELR { match value { false => DST_H2SELR :: SW , true => DST_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == DST_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == DST_H2SELR :: HW } } # [ doc = "Possible values of the field `SOD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SODR { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SODR :: DISABLE => false , SODR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SODR { match value { false => SODR :: DISABLE , true => SODR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == SODR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SODR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_IF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IFR { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IFR :: DISABLE => false , LOCK_IFR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IFR { match value { false => LOCK_IFR :: DISABLE , true => LOCK_IFR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_IFR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == LOCK_IFR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_B`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_BR { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE , # [ doc = r" Reserved" ] _Reserved ( bool ) } impl LOCK_BR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_BR :: DISABLE => false , LOCK_BR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_BR { match value { false => LOCK_BR :: DISABLE , i => LOCK_BR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_BR :: DISABLE } } # [ doc = "Possible values of the field `LOCK_IF_L`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IF_LR { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IF_LR :: CHUNK => false , LOCK_IF_LR :: BUFFER => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IF_LR { match value { false => LOCK_IF_LR :: CHUNK , true => LOCK_IF_LR :: BUFFER , } } # [ doc = "Checks if the value of the field is `CHUNK`" ] # [ inline ] pub fn is_chunk ( & self ) -> bool { * self == LOCK_IF_LR :: CHUNK } # [ doc = "Checks if the value of the field is `BUFFER`" ] # [ inline ] pub fn is_buffer ( & self ) -> bool { * self == LOCK_IF_LR :: BUFFER } } # [ doc = r" Value of the field" ] pub struct AHB_PROTR { bits : u8 , } impl AHB_PROTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FIFOCFG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FIFOCFGR { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FIFOCFGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FIFOCFGR :: ALAP_CFG => 0 , FIFOCFGR :: HALF_CFG => 0x01 , FIFOCFGR :: ASAP_CFG => 0x02 , FIFOCFGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FIFOCFGR { match value { 0 => FIFOCFGR :: ALAP_CFG , 1 => FIFOCFGR :: HALF_CFG , 2 => FIFOCFGR :: ASAP_CFG , i => FIFOCFGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ALAP_CFG`" ] # [ inline ] pub fn is_alap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ALAP_CFG } # [ doc = "Checks if the value of the field is `HALF_CFG`" ] # [ inline ] pub fn is_half_cfg ( & self ) -> bool { * self == FIFOCFGR :: HALF_CFG } # [ doc = "Checks if the value of the field is `ASAP_CFG`" ] # [ inline ] pub fn is_asap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ASAP_CFG } } # [ doc = r" Proxy" ] pub struct _SRC_PERW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_PERW < '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 } } # [ doc = r" Proxy" ] pub struct _DST_PERW < 'a > { w : & 'a mut W , } impl < 'a > _DST_PERW < '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 = "Values that can be written to the field `SRC_H2SEL`" ] pub enum SRC_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_H2SELW :: SW => false , SRC_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _SRC_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_H2SEL`" ] pub enum DST_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_H2SELW :: SW => false , DST_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _DST_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _DST_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SOD`" ] pub enum SODW { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SODW :: DISABLE => false , SODW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SODW < 'a > { w : & 'a mut W , } impl < 'a > _SODW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SODW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( SODW :: DISABLE ) } # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SODW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF`" ] pub enum LOCK_IFW { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IFW :: DISABLE => false , LOCK_IFW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IFW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IFW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Interface Lock capability is disabled" ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: DISABLE ) } # [ doc = "Interface Lock capability is enabled" ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_B`" ] pub enum LOCK_BW { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE } impl LOCK_BW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_BW :: DISABLE => false } } } # [ doc = r" Proxy" ] pub struct _LOCK_BW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_BW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_BW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "AHB Bus Locking capability is disabled." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_BW :: DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF_L`" ] pub enum LOCK_IF_LW { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IF_LW :: CHUNK => false , LOCK_IF_LW :: BUFFER => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IF_LW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IF_LW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IF_LW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] # [ inline ] pub fn chunk ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: CHUNK ) } # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] # [ inline ] pub fn buffer ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: BUFFER ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AHB_PROTW < 'a > { w : & 'a mut W , } impl < 'a > _AHB_PROTW < '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 = "Values that can be written to the field `FIFOCFG`" ] pub enum FIFOCFGW { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG } impl FIFOCFGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FIFOCFGW :: ALAP_CFG => 0 , FIFOCFGW :: HALF_CFG => 1 , FIFOCFGW :: ASAP_CFG => 2 } } } # [ doc = r" Proxy" ] pub struct _FIFOCFGW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCFGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FIFOCFGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] # [ inline ] pub fn alap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ALAP_CFG ) } # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] # [ inline ] pub fn half_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: HALF_CFG ) } # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] # [ inline ] pub fn asap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ASAP_CFG ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & self ) -> SRC_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SRC_PERR { bits } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & self ) -> DST_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DST_PERR { bits } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & self ) -> SRC_H2SELR { SRC_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & self ) -> DST_H2SELR { DST_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & self ) -> SODR { SODR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & self ) -> LOCK_IFR { LOCK_IFR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & self ) -> LOCK_BR { LOCK_BR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & self ) -> LOCK_IF_LR { LOCK_IF_LR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & self ) -> AHB_PROTR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; AHB_PROTR { bits } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & self ) -> FIFOCFGR { FIFOCFGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100_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 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & mut self ) -> _SRC_PERW { _SRC_PERW { w : self } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & mut self ) -> _DST_PERW { _DST_PERW { w : self } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & mut self ) -> _SRC_H2SELW { _SRC_H2SELW { w : self } } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & mut self ) -> _DST_H2SELW { _DST_H2SELW { w : self } } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & mut self ) -> _SODW { _SODW { w : self } } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & mut self ) -> _LOCK_IFW { _LOCK_IFW { w : self } } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & mut self ) -> _LOCK_BW { _LOCK_BW { w : self } } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & mut self ) -> _LOCK_IF_LW { _LOCK_IF_LW { w : self } } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & mut self ) -> _AHB_PROTW { _AHB_PROTW { w : self } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & mut self ) -> _FIFOCFGW { _FIFOCFGW { w : self } } } } # [ doc = "DMAC Channel Source Address Register (ch_num = 1)" ] pub struct SADDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Source Address Register (ch_num = 1)" ] pub mod saddr1 { # [ 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 :: SADDR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADDRR { bits : u32 , } impl SADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADDRW < 'a > { w : & 'a mut W , } impl < 'a > _SADDRW < '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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & self ) -> SADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; SADDRR { 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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & mut self ) -> _SADDRW { _SADDRW { w : self } } } } # [ doc = "DMAC Channel Destination Address Register (ch_num = 1)" ] pub struct DADDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Destination Address Register (ch_num = 1)" ] pub mod daddr1 { # [ 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 :: DADDR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DADDRR { bits : u32 , } impl DADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DADDRW < 'a > { w : & 'a mut W , } impl < 'a > _DADDRW < '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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & self ) -> DADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DADDRR { 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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & mut self ) -> _DADDRW { _DADDRW { w : self } } } } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 1)" ] pub struct DSCR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 1)" ] pub mod dscr1 { # [ 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 :: DSCR1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DSCRR { bits : u32 , } impl DSCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DSCRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & self ) -> DSCRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DSCRR { 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 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & mut self ) -> _DSCRW { _DSCRW { w : self } } } } # [ doc = "DMAC Channel Control A Register (ch_num = 1)" ] pub struct CTRLA1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control A Register (ch_num = 1)" ] pub mod ctrla1 { # [ 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 :: CTRLA1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BTSIZER { bits : u16 , } impl BTSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = "Possible values of the field `SCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SCSIZER :: CHK_1 => 0 , SCSIZER :: CHK_4 => 0x01 , SCSIZER :: CHK_8 => 0x02 , SCSIZER :: CHK_16 => 0x03 , SCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SCSIZER { match value { 0 => SCSIZER :: CHK_1 , 1 => SCSIZER :: CHK_4 , 2 => SCSIZER :: CHK_8 , 3 => SCSIZER :: CHK_16 , i => SCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == SCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == SCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == SCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == SCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `DCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DCSIZER :: CHK_1 => 0 , DCSIZER :: CHK_4 => 0x01 , DCSIZER :: CHK_8 => 0x02 , DCSIZER :: CHK_16 => 0x03 , DCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DCSIZER { match value { 0 => DCSIZER :: CHK_1 , 1 => DCSIZER :: CHK_4 , 2 => DCSIZER :: CHK_8 , 3 => DCSIZER :: CHK_16 , i => DCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == DCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == DCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == DCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == DCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `SRC_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_WIDTHR :: BYTE => 0 , SRC_WIDTHR :: HALF_WORD => 0x01 , SRC_WIDTHR :: WORD => 0x02 , SRC_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_WIDTHR { match value { 0 => SRC_WIDTHR :: BYTE , 1 => SRC_WIDTHR :: HALF_WORD , 2 => SRC_WIDTHR :: WORD , i => SRC_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == SRC_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == SRC_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == SRC_WIDTHR :: WORD } } # [ doc = "Possible values of the field `DST_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_WIDTHR :: BYTE => 0 , DST_WIDTHR :: HALF_WORD => 0x01 , DST_WIDTHR :: WORD => 0x02 , DST_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_WIDTHR { match value { 0 => DST_WIDTHR :: BYTE , 1 => DST_WIDTHR :: HALF_WORD , 2 => DST_WIDTHR :: WORD , i => DST_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == DST_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == DST_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == DST_WIDTHR :: WORD } } # [ doc = r" Value of the field" ] pub struct DONER { bits : bool , } impl DONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _BTSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _BTSIZEW < '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 } } # [ doc = "Values that can be written to the field `SCSIZE`" ] pub enum SCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl SCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SCSIZEW :: CHK_1 => 0 , SCSIZEW :: CHK_4 => 1 , SCSIZEW :: CHK_8 => 2 , SCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _SCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _SCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_16 ) } # [ 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `DCSIZE`" ] pub enum DCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl DCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DCSIZEW :: CHK_1 => 0 , DCSIZEW :: CHK_4 => 1 , DCSIZEW :: CHK_8 => 2 , DCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _DCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _DCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_16 ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `SRC_WIDTH`" ] pub enum SRC_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl SRC_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_WIDTHW :: BYTE => 0 , SRC_WIDTHW :: HALF_WORD => 1 , SRC_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: WORD ) } # [ 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 = "Values that can be written to the field `DST_WIDTH`" ] pub enum DST_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl DST_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_WIDTHW :: BYTE => 0 , DST_WIDTHW :: HALF_WORD => 1 , DST_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _DST_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: WORD ) } # [ 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 _DONEW < 'a > { w : & 'a mut W , } impl < 'a > _DONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:15 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & self ) -> BTSIZER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BTSIZER { bits } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & self ) -> SCSIZER { SCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & self ) -> DCSIZER { DCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & self ) -> SRC_WIDTHR { SRC_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & self ) -> DST_WIDTHR { DST_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & self ) -> DONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DONER { 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 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & mut self ) -> _BTSIZEW { _BTSIZEW { w : self } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & mut self ) -> _SCSIZEW { _SCSIZEW { w : self } } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & mut self ) -> _DCSIZEW { _DCSIZEW { w : self } } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & mut self ) -> _SRC_WIDTHW { _SRC_WIDTHW { w : self } } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & mut self ) -> _DST_WIDTHW { _DST_WIDTHW { w : self } } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & mut self ) -> _DONEW { _DONEW { w : self } } } } # [ doc = "DMAC Channel Control B Register (ch_num = 1)" ] pub struct CTRLB1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control B Register (ch_num = 1)" ] pub mod ctrlb1 { # [ 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 :: CTRLB1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `SRC_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_DSCRR { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_DSCRR :: FETCH_FROM_MEM => false , SRC_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_DSCRR { match value { false => SRC_DSCRR :: FETCH_FROM_MEM , true => SRC_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `DST_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_DSCRR { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_DSCRR :: FETCH_FROM_MEM => false , DST_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_DSCRR { match value { false => DST_DSCRR :: FETCH_FROM_MEM , true => DST_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == DST_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == DST_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `FC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FCR { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FCR :: MEM2MEM_DMA_FC => 0 , FCR :: MEM2PER_DMA_FC => 0x01 , FCR :: PER2MEM_DMA_FC => 0x02 , FCR :: PER2PER_DMA_FC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FCR { match value { 0 => FCR :: MEM2MEM_DMA_FC , 1 => FCR :: MEM2PER_DMA_FC , 2 => FCR :: PER2MEM_DMA_FC , 3 => FCR :: PER2PER_DMA_FC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MEM2MEM_DMA_FC`" ] # [ inline ] pub fn is_mem2mem_dma_fc ( & self ) -> bool { * self == FCR :: MEM2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `MEM2PER_DMA_FC`" ] # [ inline ] pub fn is_mem2per_dma_fc ( & self ) -> bool { * self == FCR :: MEM2PER_DMA_FC } # [ doc = "Checks if the value of the field is `PER2MEM_DMA_FC`" ] # [ inline ] pub fn is_per2mem_dma_fc ( & self ) -> bool { * self == FCR :: PER2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `PER2PER_DMA_FC`" ] # [ inline ] pub fn is_per2per_dma_fc ( & self ) -> bool { * self == FCR :: PER2PER_DMA_FC } } # [ doc = "Possible values of the field `SRC_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_INCRR { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_INCRR :: INCREMENTING => 0 , SRC_INCRR :: DECREMENTING => 0x01 , SRC_INCRR :: FIXED => 0x02 , SRC_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_INCRR { match value { 0 => SRC_INCRR :: INCREMENTING , 1 => SRC_INCRR :: DECREMENTING , 2 => SRC_INCRR :: FIXED , i => SRC_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == SRC_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == SRC_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == SRC_INCRR :: FIXED } } # [ doc = "Possible values of the field `DST_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_INCRR { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_INCRR :: INCREMENTING => 0 , DST_INCRR :: DECREMENTING => 0x01 , DST_INCRR :: FIXED => 0x02 , DST_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_INCRR { match value { 0 => DST_INCRR :: INCREMENTING , 1 => DST_INCRR :: DECREMENTING , 2 => DST_INCRR :: FIXED , i => DST_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == DST_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == DST_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == DST_INCRR :: FIXED } } # [ doc = r" Value of the field" ] pub struct IENR { bits : bool , } impl IENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `SRC_DSCR`" ] pub enum SRC_DSCRW { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_DSCRW :: FETCH_FROM_MEM => false , SRC_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _SRC_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_DSCR`" ] pub enum DST_DSCRW { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_DSCRW :: FETCH_FROM_MEM => false , DST_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _DST_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FC`" ] pub enum FCW { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCW :: MEM2MEM_DMA_FC => 0 , FCW :: MEM2PER_DMA_FC => 1 , FCW :: PER2MEM_DMA_FC => 2 , FCW :: PER2PER_DMA_FC => 3 } } } # [ doc = r" Proxy" ] pub struct _FCW < 'a > { w : & 'a mut W , } impl < 'a > _FCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2MEM_DMA_FC ) } # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2PER_DMA_FC ) } # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn per2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2MEM_DMA_FC ) } # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn per2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2PER_DMA_FC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SRC_INCR`" ] pub enum SRC_INCRW { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED } impl SRC_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_INCRW :: INCREMENTING => 0 , SRC_INCRW :: DECREMENTING => 1 , SRC_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The source address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: INCREMENTING ) } # [ doc = "The source address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: DECREMENTING ) } # [ doc = "The source address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: FIXED ) } # [ 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 = "Values that can be written to the field `DST_INCR`" ] pub enum DST_INCRW { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED } impl DST_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_INCRW :: INCREMENTING => 0 , DST_INCRW :: DECREMENTING => 1 , DST_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The destination address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: INCREMENTING ) } # [ doc = "The destination address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: DECREMENTING ) } # [ doc = "The destination address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: FIXED ) } # [ 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 _IENW < 'a > { w : & 'a mut W , } impl < 'a > _IENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 16 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & self ) -> SRC_DSCRR { SRC_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & self ) -> DST_DSCRR { DST_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & self ) -> FCR { FCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & self ) -> SRC_INCRR { SRC_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & self ) -> DST_INCRR { DST_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & self ) -> IENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IENR { 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 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & mut self ) -> _SRC_DSCRW { _SRC_DSCRW { w : self } } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & mut self ) -> _DST_DSCRW { _DST_DSCRW { w : self } } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & mut self ) -> _FCW { _FCW { w : self } } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & mut self ) -> _SRC_INCRW { _SRC_INCRW { w : self } } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & mut self ) -> _DST_INCRW { _DST_INCRW { w : self } } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & mut self ) -> _IENW { _IENW { w : self } } } } # [ doc = "DMAC Channel Configuration Register (ch_num = 1)" ] pub struct CFG1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Configuration Register (ch_num = 1)" ] pub mod cfg1 { # [ 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 :: CFG1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SRC_PERR { bits : u8 , } impl SRC_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DST_PERR { bits : u8 , } impl DST_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SRC_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_H2SELR :: SW => false , SRC_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_H2SELR { match value { false => SRC_H2SELR :: SW , true => SRC_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == SRC_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == SRC_H2SELR :: HW } } # [ doc = "Possible values of the field `DST_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_H2SELR :: SW => false , DST_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_H2SELR { match value { false => DST_H2SELR :: SW , true => DST_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == DST_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == DST_H2SELR :: HW } } # [ doc = "Possible values of the field `SOD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SODR { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SODR :: DISABLE => false , SODR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SODR { match value { false => SODR :: DISABLE , true => SODR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == SODR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SODR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_IF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IFR { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IFR :: DISABLE => false , LOCK_IFR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IFR { match value { false => LOCK_IFR :: DISABLE , true => LOCK_IFR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_IFR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == LOCK_IFR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_B`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_BR { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE , # [ doc = r" Reserved" ] _Reserved ( bool ) } impl LOCK_BR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_BR :: DISABLE => false , LOCK_BR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_BR { match value { false => LOCK_BR :: DISABLE , i => LOCK_BR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_BR :: DISABLE } } # [ doc = "Possible values of the field `LOCK_IF_L`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IF_LR { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IF_LR :: CHUNK => false , LOCK_IF_LR :: BUFFER => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IF_LR { match value { false => LOCK_IF_LR :: CHUNK , true => LOCK_IF_LR :: BUFFER , } } # [ doc = "Checks if the value of the field is `CHUNK`" ] # [ inline ] pub fn is_chunk ( & self ) -> bool { * self == LOCK_IF_LR :: CHUNK } # [ doc = "Checks if the value of the field is `BUFFER`" ] # [ inline ] pub fn is_buffer ( & self ) -> bool { * self == LOCK_IF_LR :: BUFFER } } # [ doc = r" Value of the field" ] pub struct AHB_PROTR { bits : u8 , } impl AHB_PROTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FIFOCFG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FIFOCFGR { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FIFOCFGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FIFOCFGR :: ALAP_CFG => 0 , FIFOCFGR :: HALF_CFG => 0x01 , FIFOCFGR :: ASAP_CFG => 0x02 , FIFOCFGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FIFOCFGR { match value { 0 => FIFOCFGR :: ALAP_CFG , 1 => FIFOCFGR :: HALF_CFG , 2 => FIFOCFGR :: ASAP_CFG , i => FIFOCFGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ALAP_CFG`" ] # [ inline ] pub fn is_alap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ALAP_CFG } # [ doc = "Checks if the value of the field is `HALF_CFG`" ] # [ inline ] pub fn is_half_cfg ( & self ) -> bool { * self == FIFOCFGR :: HALF_CFG } # [ doc = "Checks if the value of the field is `ASAP_CFG`" ] # [ inline ] pub fn is_asap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ASAP_CFG } } # [ doc = r" Proxy" ] pub struct _SRC_PERW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_PERW < '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 } } # [ doc = r" Proxy" ] pub struct _DST_PERW < 'a > { w : & 'a mut W , } impl < 'a > _DST_PERW < '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 = "Values that can be written to the field `SRC_H2SEL`" ] pub enum SRC_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_H2SELW :: SW => false , SRC_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _SRC_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_H2SEL`" ] pub enum DST_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_H2SELW :: SW => false , DST_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _DST_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _DST_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SOD`" ] pub enum SODW { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SODW :: DISABLE => false , SODW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SODW < 'a > { w : & 'a mut W , } impl < 'a > _SODW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SODW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( SODW :: DISABLE ) } # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SODW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF`" ] pub enum LOCK_IFW { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IFW :: DISABLE => false , LOCK_IFW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IFW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IFW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Interface Lock capability is disabled" ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: DISABLE ) } # [ doc = "Interface Lock capability is enabled" ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_B`" ] pub enum LOCK_BW { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE } impl LOCK_BW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_BW :: DISABLE => false } } } # [ doc = r" Proxy" ] pub struct _LOCK_BW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_BW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_BW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "AHB Bus Locking capability is disabled." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_BW :: DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF_L`" ] pub enum LOCK_IF_LW { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IF_LW :: CHUNK => false , LOCK_IF_LW :: BUFFER => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IF_LW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IF_LW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IF_LW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] # [ inline ] pub fn chunk ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: CHUNK ) } # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] # [ inline ] pub fn buffer ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: BUFFER ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AHB_PROTW < 'a > { w : & 'a mut W , } impl < 'a > _AHB_PROTW < '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 = "Values that can be written to the field `FIFOCFG`" ] pub enum FIFOCFGW { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG } impl FIFOCFGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FIFOCFGW :: ALAP_CFG => 0 , FIFOCFGW :: HALF_CFG => 1 , FIFOCFGW :: ASAP_CFG => 2 } } } # [ doc = r" Proxy" ] pub struct _FIFOCFGW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCFGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FIFOCFGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] # [ inline ] pub fn alap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ALAP_CFG ) } # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] # [ inline ] pub fn half_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: HALF_CFG ) } # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] # [ inline ] pub fn asap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ASAP_CFG ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & self ) -> SRC_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SRC_PERR { bits } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & self ) -> DST_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DST_PERR { bits } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & self ) -> SRC_H2SELR { SRC_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & self ) -> DST_H2SELR { DST_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & self ) -> SODR { SODR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & self ) -> LOCK_IFR { LOCK_IFR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & self ) -> LOCK_BR { LOCK_BR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & self ) -> LOCK_IF_LR { LOCK_IF_LR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & self ) -> AHB_PROTR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; AHB_PROTR { bits } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & self ) -> FIFOCFGR { FIFOCFGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100_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 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & mut self ) -> _SRC_PERW { _SRC_PERW { w : self } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & mut self ) -> _DST_PERW { _DST_PERW { w : self } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & mut self ) -> _SRC_H2SELW { _SRC_H2SELW { w : self } } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & mut self ) -> _DST_H2SELW { _DST_H2SELW { w : self } } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & mut self ) -> _SODW { _SODW { w : self } } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & mut self ) -> _LOCK_IFW { _LOCK_IFW { w : self } } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & mut self ) -> _LOCK_BW { _LOCK_BW { w : self } } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & mut self ) -> _LOCK_IF_LW { _LOCK_IF_LW { w : self } } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & mut self ) -> _AHB_PROTW { _AHB_PROTW { w : self } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & mut self ) -> _FIFOCFGW { _FIFOCFGW { w : self } } } } # [ doc = "DMAC Channel Source Address Register (ch_num = 2)" ] pub struct SADDR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Source Address Register (ch_num = 2)" ] pub mod saddr2 { # [ 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 :: SADDR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADDRR { bits : u32 , } impl SADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADDRW < 'a > { w : & 'a mut W , } impl < 'a > _SADDRW < '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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & self ) -> SADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; SADDRR { 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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & mut self ) -> _SADDRW { _SADDRW { w : self } } } } # [ doc = "DMAC Channel Destination Address Register (ch_num = 2)" ] pub struct DADDR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Destination Address Register (ch_num = 2)" ] pub mod daddr2 { # [ 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 :: DADDR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DADDRR { bits : u32 , } impl DADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DADDRW < 'a > { w : & 'a mut W , } impl < 'a > _DADDRW < '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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & self ) -> DADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DADDRR { 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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & mut self ) -> _DADDRW { _DADDRW { w : self } } } } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 2)" ] pub struct DSCR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 2)" ] pub mod dscr2 { # [ 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 :: DSCR2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DSCRR { bits : u32 , } impl DSCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DSCRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & self ) -> DSCRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DSCRR { 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 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & mut self ) -> _DSCRW { _DSCRW { w : self } } } } # [ doc = "DMAC Channel Control A Register (ch_num = 2)" ] pub struct CTRLA2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control A Register (ch_num = 2)" ] pub mod ctrla2 { # [ 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 :: CTRLA2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BTSIZER { bits : u16 , } impl BTSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = "Possible values of the field `SCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SCSIZER :: CHK_1 => 0 , SCSIZER :: CHK_4 => 0x01 , SCSIZER :: CHK_8 => 0x02 , SCSIZER :: CHK_16 => 0x03 , SCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SCSIZER { match value { 0 => SCSIZER :: CHK_1 , 1 => SCSIZER :: CHK_4 , 2 => SCSIZER :: CHK_8 , 3 => SCSIZER :: CHK_16 , i => SCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == SCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == SCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == SCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == SCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `DCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DCSIZER :: CHK_1 => 0 , DCSIZER :: CHK_4 => 0x01 , DCSIZER :: CHK_8 => 0x02 , DCSIZER :: CHK_16 => 0x03 , DCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DCSIZER { match value { 0 => DCSIZER :: CHK_1 , 1 => DCSIZER :: CHK_4 , 2 => DCSIZER :: CHK_8 , 3 => DCSIZER :: CHK_16 , i => DCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == DCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == DCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == DCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == DCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `SRC_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_WIDTHR :: BYTE => 0 , SRC_WIDTHR :: HALF_WORD => 0x01 , SRC_WIDTHR :: WORD => 0x02 , SRC_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_WIDTHR { match value { 0 => SRC_WIDTHR :: BYTE , 1 => SRC_WIDTHR :: HALF_WORD , 2 => SRC_WIDTHR :: WORD , i => SRC_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == SRC_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == SRC_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == SRC_WIDTHR :: WORD } } # [ doc = "Possible values of the field `DST_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_WIDTHR :: BYTE => 0 , DST_WIDTHR :: HALF_WORD => 0x01 , DST_WIDTHR :: WORD => 0x02 , DST_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_WIDTHR { match value { 0 => DST_WIDTHR :: BYTE , 1 => DST_WIDTHR :: HALF_WORD , 2 => DST_WIDTHR :: WORD , i => DST_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == DST_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == DST_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == DST_WIDTHR :: WORD } } # [ doc = r" Value of the field" ] pub struct DONER { bits : bool , } impl DONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _BTSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _BTSIZEW < '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 } } # [ doc = "Values that can be written to the field `SCSIZE`" ] pub enum SCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl SCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SCSIZEW :: CHK_1 => 0 , SCSIZEW :: CHK_4 => 1 , SCSIZEW :: CHK_8 => 2 , SCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _SCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _SCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_16 ) } # [ 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `DCSIZE`" ] pub enum DCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl DCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DCSIZEW :: CHK_1 => 0 , DCSIZEW :: CHK_4 => 1 , DCSIZEW :: CHK_8 => 2 , DCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _DCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _DCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_16 ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `SRC_WIDTH`" ] pub enum SRC_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl SRC_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_WIDTHW :: BYTE => 0 , SRC_WIDTHW :: HALF_WORD => 1 , SRC_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: WORD ) } # [ 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 = "Values that can be written to the field `DST_WIDTH`" ] pub enum DST_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl DST_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_WIDTHW :: BYTE => 0 , DST_WIDTHW :: HALF_WORD => 1 , DST_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _DST_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: WORD ) } # [ 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 _DONEW < 'a > { w : & 'a mut W , } impl < 'a > _DONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:15 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & self ) -> BTSIZER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BTSIZER { bits } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & self ) -> SCSIZER { SCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & self ) -> DCSIZER { DCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & self ) -> SRC_WIDTHR { SRC_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & self ) -> DST_WIDTHR { DST_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & self ) -> DONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DONER { 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 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & mut self ) -> _BTSIZEW { _BTSIZEW { w : self } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & mut self ) -> _SCSIZEW { _SCSIZEW { w : self } } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & mut self ) -> _DCSIZEW { _DCSIZEW { w : self } } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & mut self ) -> _SRC_WIDTHW { _SRC_WIDTHW { w : self } } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & mut self ) -> _DST_WIDTHW { _DST_WIDTHW { w : self } } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & mut self ) -> _DONEW { _DONEW { w : self } } } } # [ doc = "DMAC Channel Control B Register (ch_num = 2)" ] pub struct CTRLB2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control B Register (ch_num = 2)" ] pub mod ctrlb2 { # [ 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 :: CTRLB2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `SRC_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_DSCRR { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_DSCRR :: FETCH_FROM_MEM => false , SRC_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_DSCRR { match value { false => SRC_DSCRR :: FETCH_FROM_MEM , true => SRC_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `DST_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_DSCRR { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_DSCRR :: FETCH_FROM_MEM => false , DST_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_DSCRR { match value { false => DST_DSCRR :: FETCH_FROM_MEM , true => DST_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == DST_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == DST_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `FC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FCR { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FCR :: MEM2MEM_DMA_FC => 0 , FCR :: MEM2PER_DMA_FC => 0x01 , FCR :: PER2MEM_DMA_FC => 0x02 , FCR :: PER2PER_DMA_FC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FCR { match value { 0 => FCR :: MEM2MEM_DMA_FC , 1 => FCR :: MEM2PER_DMA_FC , 2 => FCR :: PER2MEM_DMA_FC , 3 => FCR :: PER2PER_DMA_FC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MEM2MEM_DMA_FC`" ] # [ inline ] pub fn is_mem2mem_dma_fc ( & self ) -> bool { * self == FCR :: MEM2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `MEM2PER_DMA_FC`" ] # [ inline ] pub fn is_mem2per_dma_fc ( & self ) -> bool { * self == FCR :: MEM2PER_DMA_FC } # [ doc = "Checks if the value of the field is `PER2MEM_DMA_FC`" ] # [ inline ] pub fn is_per2mem_dma_fc ( & self ) -> bool { * self == FCR :: PER2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `PER2PER_DMA_FC`" ] # [ inline ] pub fn is_per2per_dma_fc ( & self ) -> bool { * self == FCR :: PER2PER_DMA_FC } } # [ doc = "Possible values of the field `SRC_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_INCRR { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_INCRR :: INCREMENTING => 0 , SRC_INCRR :: DECREMENTING => 0x01 , SRC_INCRR :: FIXED => 0x02 , SRC_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_INCRR { match value { 0 => SRC_INCRR :: INCREMENTING , 1 => SRC_INCRR :: DECREMENTING , 2 => SRC_INCRR :: FIXED , i => SRC_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == SRC_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == SRC_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == SRC_INCRR :: FIXED } } # [ doc = "Possible values of the field `DST_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_INCRR { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_INCRR :: INCREMENTING => 0 , DST_INCRR :: DECREMENTING => 0x01 , DST_INCRR :: FIXED => 0x02 , DST_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_INCRR { match value { 0 => DST_INCRR :: INCREMENTING , 1 => DST_INCRR :: DECREMENTING , 2 => DST_INCRR :: FIXED , i => DST_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == DST_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == DST_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == DST_INCRR :: FIXED } } # [ doc = r" Value of the field" ] pub struct IENR { bits : bool , } impl IENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `SRC_DSCR`" ] pub enum SRC_DSCRW { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_DSCRW :: FETCH_FROM_MEM => false , SRC_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _SRC_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_DSCR`" ] pub enum DST_DSCRW { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_DSCRW :: FETCH_FROM_MEM => false , DST_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _DST_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FC`" ] pub enum FCW { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCW :: MEM2MEM_DMA_FC => 0 , FCW :: MEM2PER_DMA_FC => 1 , FCW :: PER2MEM_DMA_FC => 2 , FCW :: PER2PER_DMA_FC => 3 } } } # [ doc = r" Proxy" ] pub struct _FCW < 'a > { w : & 'a mut W , } impl < 'a > _FCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2MEM_DMA_FC ) } # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2PER_DMA_FC ) } # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn per2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2MEM_DMA_FC ) } # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn per2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2PER_DMA_FC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SRC_INCR`" ] pub enum SRC_INCRW { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED } impl SRC_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_INCRW :: INCREMENTING => 0 , SRC_INCRW :: DECREMENTING => 1 , SRC_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The source address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: INCREMENTING ) } # [ doc = "The source address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: DECREMENTING ) } # [ doc = "The source address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: FIXED ) } # [ 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 = "Values that can be written to the field `DST_INCR`" ] pub enum DST_INCRW { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED } impl DST_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_INCRW :: INCREMENTING => 0 , DST_INCRW :: DECREMENTING => 1 , DST_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The destination address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: INCREMENTING ) } # [ doc = "The destination address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: DECREMENTING ) } # [ doc = "The destination address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: FIXED ) } # [ 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 _IENW < 'a > { w : & 'a mut W , } impl < 'a > _IENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 16 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & self ) -> SRC_DSCRR { SRC_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & self ) -> DST_DSCRR { DST_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & self ) -> FCR { FCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & self ) -> SRC_INCRR { SRC_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & self ) -> DST_INCRR { DST_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & self ) -> IENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IENR { 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 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & mut self ) -> _SRC_DSCRW { _SRC_DSCRW { w : self } } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & mut self ) -> _DST_DSCRW { _DST_DSCRW { w : self } } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & mut self ) -> _FCW { _FCW { w : self } } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & mut self ) -> _SRC_INCRW { _SRC_INCRW { w : self } } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & mut self ) -> _DST_INCRW { _DST_INCRW { w : self } } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & mut self ) -> _IENW { _IENW { w : self } } } } # [ doc = "DMAC Channel Configuration Register (ch_num = 2)" ] pub struct CFG2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Configuration Register (ch_num = 2)" ] pub mod cfg2 { # [ 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 :: CFG2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SRC_PERR { bits : u8 , } impl SRC_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DST_PERR { bits : u8 , } impl DST_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SRC_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_H2SELR :: SW => false , SRC_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_H2SELR { match value { false => SRC_H2SELR :: SW , true => SRC_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == SRC_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == SRC_H2SELR :: HW } } # [ doc = "Possible values of the field `DST_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_H2SELR :: SW => false , DST_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_H2SELR { match value { false => DST_H2SELR :: SW , true => DST_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == DST_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == DST_H2SELR :: HW } } # [ doc = "Possible values of the field `SOD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SODR { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SODR :: DISABLE => false , SODR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SODR { match value { false => SODR :: DISABLE , true => SODR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == SODR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SODR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_IF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IFR { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IFR :: DISABLE => false , LOCK_IFR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IFR { match value { false => LOCK_IFR :: DISABLE , true => LOCK_IFR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_IFR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == LOCK_IFR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_B`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_BR { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE , # [ doc = r" Reserved" ] _Reserved ( bool ) } impl LOCK_BR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_BR :: DISABLE => false , LOCK_BR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_BR { match value { false => LOCK_BR :: DISABLE , i => LOCK_BR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_BR :: DISABLE } } # [ doc = "Possible values of the field `LOCK_IF_L`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IF_LR { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IF_LR :: CHUNK => false , LOCK_IF_LR :: BUFFER => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IF_LR { match value { false => LOCK_IF_LR :: CHUNK , true => LOCK_IF_LR :: BUFFER , } } # [ doc = "Checks if the value of the field is `CHUNK`" ] # [ inline ] pub fn is_chunk ( & self ) -> bool { * self == LOCK_IF_LR :: CHUNK } # [ doc = "Checks if the value of the field is `BUFFER`" ] # [ inline ] pub fn is_buffer ( & self ) -> bool { * self == LOCK_IF_LR :: BUFFER } } # [ doc = r" Value of the field" ] pub struct AHB_PROTR { bits : u8 , } impl AHB_PROTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FIFOCFG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FIFOCFGR { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FIFOCFGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FIFOCFGR :: ALAP_CFG => 0 , FIFOCFGR :: HALF_CFG => 0x01 , FIFOCFGR :: ASAP_CFG => 0x02 , FIFOCFGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FIFOCFGR { match value { 0 => FIFOCFGR :: ALAP_CFG , 1 => FIFOCFGR :: HALF_CFG , 2 => FIFOCFGR :: ASAP_CFG , i => FIFOCFGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ALAP_CFG`" ] # [ inline ] pub fn is_alap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ALAP_CFG } # [ doc = "Checks if the value of the field is `HALF_CFG`" ] # [ inline ] pub fn is_half_cfg ( & self ) -> bool { * self == FIFOCFGR :: HALF_CFG } # [ doc = "Checks if the value of the field is `ASAP_CFG`" ] # [ inline ] pub fn is_asap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ASAP_CFG } } # [ doc = r" Proxy" ] pub struct _SRC_PERW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_PERW < '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 } } # [ doc = r" Proxy" ] pub struct _DST_PERW < 'a > { w : & 'a mut W , } impl < 'a > _DST_PERW < '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 = "Values that can be written to the field `SRC_H2SEL`" ] pub enum SRC_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_H2SELW :: SW => false , SRC_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _SRC_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_H2SEL`" ] pub enum DST_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_H2SELW :: SW => false , DST_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _DST_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _DST_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SOD`" ] pub enum SODW { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SODW :: DISABLE => false , SODW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SODW < 'a > { w : & 'a mut W , } impl < 'a > _SODW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SODW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( SODW :: DISABLE ) } # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SODW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF`" ] pub enum LOCK_IFW { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IFW :: DISABLE => false , LOCK_IFW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IFW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IFW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Interface Lock capability is disabled" ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: DISABLE ) } # [ doc = "Interface Lock capability is enabled" ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_B`" ] pub enum LOCK_BW { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE } impl LOCK_BW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_BW :: DISABLE => false } } } # [ doc = r" Proxy" ] pub struct _LOCK_BW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_BW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_BW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "AHB Bus Locking capability is disabled." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_BW :: DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF_L`" ] pub enum LOCK_IF_LW { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IF_LW :: CHUNK => false , LOCK_IF_LW :: BUFFER => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IF_LW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IF_LW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IF_LW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] # [ inline ] pub fn chunk ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: CHUNK ) } # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] # [ inline ] pub fn buffer ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: BUFFER ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AHB_PROTW < 'a > { w : & 'a mut W , } impl < 'a > _AHB_PROTW < '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 = "Values that can be written to the field `FIFOCFG`" ] pub enum FIFOCFGW { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG } impl FIFOCFGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FIFOCFGW :: ALAP_CFG => 0 , FIFOCFGW :: HALF_CFG => 1 , FIFOCFGW :: ASAP_CFG => 2 } } } # [ doc = r" Proxy" ] pub struct _FIFOCFGW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCFGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FIFOCFGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] # [ inline ] pub fn alap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ALAP_CFG ) } # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] # [ inline ] pub fn half_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: HALF_CFG ) } # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] # [ inline ] pub fn asap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ASAP_CFG ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & self ) -> SRC_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SRC_PERR { bits } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & self ) -> DST_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DST_PERR { bits } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & self ) -> SRC_H2SELR { SRC_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & self ) -> DST_H2SELR { DST_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & self ) -> SODR { SODR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & self ) -> LOCK_IFR { LOCK_IFR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & self ) -> LOCK_BR { LOCK_BR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & self ) -> LOCK_IF_LR { LOCK_IF_LR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & self ) -> AHB_PROTR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; AHB_PROTR { bits } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & self ) -> FIFOCFGR { FIFOCFGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100_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 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & mut self ) -> _SRC_PERW { _SRC_PERW { w : self } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & mut self ) -> _DST_PERW { _DST_PERW { w : self } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & mut self ) -> _SRC_H2SELW { _SRC_H2SELW { w : self } } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & mut self ) -> _DST_H2SELW { _DST_H2SELW { w : self } } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & mut self ) -> _SODW { _SODW { w : self } } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & mut self ) -> _LOCK_IFW { _LOCK_IFW { w : self } } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & mut self ) -> _LOCK_BW { _LOCK_BW { w : self } } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & mut self ) -> _LOCK_IF_LW { _LOCK_IF_LW { w : self } } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & mut self ) -> _AHB_PROTW { _AHB_PROTW { w : self } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & mut self ) -> _FIFOCFGW { _FIFOCFGW { w : self } } } } # [ doc = "DMAC Channel Source Address Register (ch_num = 3)" ] pub struct SADDR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Source Address Register (ch_num = 3)" ] pub mod saddr3 { # [ 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 :: SADDR3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADDRR { bits : u32 , } impl SADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADDRW < 'a > { w : & 'a mut W , } impl < 'a > _SADDRW < '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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & self ) -> SADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; SADDRR { 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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & mut self ) -> _SADDRW { _SADDRW { w : self } } } } # [ doc = "DMAC Channel Destination Address Register (ch_num = 3)" ] pub struct DADDR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Destination Address Register (ch_num = 3)" ] pub mod daddr3 { # [ 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 :: DADDR3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DADDRR { bits : u32 , } impl DADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DADDRW < 'a > { w : & 'a mut W , } impl < 'a > _DADDRW < '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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & self ) -> DADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DADDRR { 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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & mut self ) -> _DADDRW { _DADDRW { w : self } } } } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 3)" ] pub struct DSCR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 3)" ] pub mod dscr3 { # [ 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 :: DSCR3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DSCRR { bits : u32 , } impl DSCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DSCRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & self ) -> DSCRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DSCRR { 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 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & mut self ) -> _DSCRW { _DSCRW { w : self } } } } # [ doc = "DMAC Channel Control A Register (ch_num = 3)" ] pub struct CTRLA3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control A Register (ch_num = 3)" ] pub mod ctrla3 { # [ 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 :: CTRLA3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BTSIZER { bits : u16 , } impl BTSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = "Possible values of the field `SCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SCSIZER :: CHK_1 => 0 , SCSIZER :: CHK_4 => 0x01 , SCSIZER :: CHK_8 => 0x02 , SCSIZER :: CHK_16 => 0x03 , SCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SCSIZER { match value { 0 => SCSIZER :: CHK_1 , 1 => SCSIZER :: CHK_4 , 2 => SCSIZER :: CHK_8 , 3 => SCSIZER :: CHK_16 , i => SCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == SCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == SCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == SCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == SCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `DCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DCSIZER :: CHK_1 => 0 , DCSIZER :: CHK_4 => 0x01 , DCSIZER :: CHK_8 => 0x02 , DCSIZER :: CHK_16 => 0x03 , DCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DCSIZER { match value { 0 => DCSIZER :: CHK_1 , 1 => DCSIZER :: CHK_4 , 2 => DCSIZER :: CHK_8 , 3 => DCSIZER :: CHK_16 , i => DCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == DCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == DCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == DCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == DCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `SRC_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_WIDTHR :: BYTE => 0 , SRC_WIDTHR :: HALF_WORD => 0x01 , SRC_WIDTHR :: WORD => 0x02 , SRC_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_WIDTHR { match value { 0 => SRC_WIDTHR :: BYTE , 1 => SRC_WIDTHR :: HALF_WORD , 2 => SRC_WIDTHR :: WORD , i => SRC_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == SRC_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == SRC_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == SRC_WIDTHR :: WORD } } # [ doc = "Possible values of the field `DST_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_WIDTHR :: BYTE => 0 , DST_WIDTHR :: HALF_WORD => 0x01 , DST_WIDTHR :: WORD => 0x02 , DST_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_WIDTHR { match value { 0 => DST_WIDTHR :: BYTE , 1 => DST_WIDTHR :: HALF_WORD , 2 => DST_WIDTHR :: WORD , i => DST_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == DST_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == DST_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == DST_WIDTHR :: WORD } } # [ doc = r" Value of the field" ] pub struct DONER { bits : bool , } impl DONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _BTSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _BTSIZEW < '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 } } # [ doc = "Values that can be written to the field `SCSIZE`" ] pub enum SCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl SCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SCSIZEW :: CHK_1 => 0 , SCSIZEW :: CHK_4 => 1 , SCSIZEW :: CHK_8 => 2 , SCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _SCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _SCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_16 ) } # [ 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `DCSIZE`" ] pub enum DCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl DCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DCSIZEW :: CHK_1 => 0 , DCSIZEW :: CHK_4 => 1 , DCSIZEW :: CHK_8 => 2 , DCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _DCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _DCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_16 ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `SRC_WIDTH`" ] pub enum SRC_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl SRC_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_WIDTHW :: BYTE => 0 , SRC_WIDTHW :: HALF_WORD => 1 , SRC_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: WORD ) } # [ 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 = "Values that can be written to the field `DST_WIDTH`" ] pub enum DST_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl DST_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_WIDTHW :: BYTE => 0 , DST_WIDTHW :: HALF_WORD => 1 , DST_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _DST_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: WORD ) } # [ 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 _DONEW < 'a > { w : & 'a mut W , } impl < 'a > _DONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:15 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & self ) -> BTSIZER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BTSIZER { bits } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & self ) -> SCSIZER { SCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & self ) -> DCSIZER { DCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & self ) -> SRC_WIDTHR { SRC_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & self ) -> DST_WIDTHR { DST_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & self ) -> DONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DONER { 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 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & mut self ) -> _BTSIZEW { _BTSIZEW { w : self } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & mut self ) -> _SCSIZEW { _SCSIZEW { w : self } } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & mut self ) -> _DCSIZEW { _DCSIZEW { w : self } } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & mut self ) -> _SRC_WIDTHW { _SRC_WIDTHW { w : self } } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & mut self ) -> _DST_WIDTHW { _DST_WIDTHW { w : self } } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & mut self ) -> _DONEW { _DONEW { w : self } } } } # [ doc = "DMAC Channel Control B Register (ch_num = 3)" ] pub struct CTRLB3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control B Register (ch_num = 3)" ] pub mod ctrlb3 { # [ 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 :: CTRLB3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `SRC_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_DSCRR { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_DSCRR :: FETCH_FROM_MEM => false , SRC_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_DSCRR { match value { false => SRC_DSCRR :: FETCH_FROM_MEM , true => SRC_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `DST_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_DSCRR { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_DSCRR :: FETCH_FROM_MEM => false , DST_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_DSCRR { match value { false => DST_DSCRR :: FETCH_FROM_MEM , true => DST_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == DST_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == DST_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `FC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FCR { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FCR :: MEM2MEM_DMA_FC => 0 , FCR :: MEM2PER_DMA_FC => 0x01 , FCR :: PER2MEM_DMA_FC => 0x02 , FCR :: PER2PER_DMA_FC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FCR { match value { 0 => FCR :: MEM2MEM_DMA_FC , 1 => FCR :: MEM2PER_DMA_FC , 2 => FCR :: PER2MEM_DMA_FC , 3 => FCR :: PER2PER_DMA_FC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MEM2MEM_DMA_FC`" ] # [ inline ] pub fn is_mem2mem_dma_fc ( & self ) -> bool { * self == FCR :: MEM2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `MEM2PER_DMA_FC`" ] # [ inline ] pub fn is_mem2per_dma_fc ( & self ) -> bool { * self == FCR :: MEM2PER_DMA_FC } # [ doc = "Checks if the value of the field is `PER2MEM_DMA_FC`" ] # [ inline ] pub fn is_per2mem_dma_fc ( & self ) -> bool { * self == FCR :: PER2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `PER2PER_DMA_FC`" ] # [ inline ] pub fn is_per2per_dma_fc ( & self ) -> bool { * self == FCR :: PER2PER_DMA_FC } } # [ doc = "Possible values of the field `SRC_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_INCRR { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_INCRR :: INCREMENTING => 0 , SRC_INCRR :: DECREMENTING => 0x01 , SRC_INCRR :: FIXED => 0x02 , SRC_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_INCRR { match value { 0 => SRC_INCRR :: INCREMENTING , 1 => SRC_INCRR :: DECREMENTING , 2 => SRC_INCRR :: FIXED , i => SRC_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == SRC_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == SRC_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == SRC_INCRR :: FIXED } } # [ doc = "Possible values of the field `DST_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_INCRR { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_INCRR :: INCREMENTING => 0 , DST_INCRR :: DECREMENTING => 0x01 , DST_INCRR :: FIXED => 0x02 , DST_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_INCRR { match value { 0 => DST_INCRR :: INCREMENTING , 1 => DST_INCRR :: DECREMENTING , 2 => DST_INCRR :: FIXED , i => DST_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == DST_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == DST_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == DST_INCRR :: FIXED } } # [ doc = r" Value of the field" ] pub struct IENR { bits : bool , } impl IENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `SRC_DSCR`" ] pub enum SRC_DSCRW { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_DSCRW :: FETCH_FROM_MEM => false , SRC_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _SRC_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_DSCR`" ] pub enum DST_DSCRW { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_DSCRW :: FETCH_FROM_MEM => false , DST_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _DST_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FC`" ] pub enum FCW { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCW :: MEM2MEM_DMA_FC => 0 , FCW :: MEM2PER_DMA_FC => 1 , FCW :: PER2MEM_DMA_FC => 2 , FCW :: PER2PER_DMA_FC => 3 } } } # [ doc = r" Proxy" ] pub struct _FCW < 'a > { w : & 'a mut W , } impl < 'a > _FCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2MEM_DMA_FC ) } # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2PER_DMA_FC ) } # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn per2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2MEM_DMA_FC ) } # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn per2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2PER_DMA_FC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SRC_INCR`" ] pub enum SRC_INCRW { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED } impl SRC_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_INCRW :: INCREMENTING => 0 , SRC_INCRW :: DECREMENTING => 1 , SRC_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The source address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: INCREMENTING ) } # [ doc = "The source address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: DECREMENTING ) } # [ doc = "The source address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: FIXED ) } # [ 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 = "Values that can be written to the field `DST_INCR`" ] pub enum DST_INCRW { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED } impl DST_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_INCRW :: INCREMENTING => 0 , DST_INCRW :: DECREMENTING => 1 , DST_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The destination address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: INCREMENTING ) } # [ doc = "The destination address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: DECREMENTING ) } # [ doc = "The destination address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: FIXED ) } # [ 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 _IENW < 'a > { w : & 'a mut W , } impl < 'a > _IENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 16 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & self ) -> SRC_DSCRR { SRC_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & self ) -> DST_DSCRR { DST_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & self ) -> FCR { FCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & self ) -> SRC_INCRR { SRC_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & self ) -> DST_INCRR { DST_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & self ) -> IENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IENR { 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 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & mut self ) -> _SRC_DSCRW { _SRC_DSCRW { w : self } } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & mut self ) -> _DST_DSCRW { _DST_DSCRW { w : self } } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & mut self ) -> _FCW { _FCW { w : self } } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & mut self ) -> _SRC_INCRW { _SRC_INCRW { w : self } } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & mut self ) -> _DST_INCRW { _DST_INCRW { w : self } } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & mut self ) -> _IENW { _IENW { w : self } } } } # [ doc = "DMAC Channel Configuration Register (ch_num = 3)" ] pub struct CFG3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Configuration Register (ch_num = 3)" ] pub mod cfg3 { # [ 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 :: CFG3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SRC_PERR { bits : u8 , } impl SRC_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DST_PERR { bits : u8 , } impl DST_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SRC_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_H2SELR :: SW => false , SRC_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_H2SELR { match value { false => SRC_H2SELR :: SW , true => SRC_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == SRC_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == SRC_H2SELR :: HW } } # [ doc = "Possible values of the field `DST_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_H2SELR :: SW => false , DST_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_H2SELR { match value { false => DST_H2SELR :: SW , true => DST_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == DST_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == DST_H2SELR :: HW } } # [ doc = "Possible values of the field `SOD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SODR { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SODR :: DISABLE => false , SODR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SODR { match value { false => SODR :: DISABLE , true => SODR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == SODR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SODR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_IF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IFR { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IFR :: DISABLE => false , LOCK_IFR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IFR { match value { false => LOCK_IFR :: DISABLE , true => LOCK_IFR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_IFR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == LOCK_IFR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_B`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_BR { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE , # [ doc = r" Reserved" ] _Reserved ( bool ) } impl LOCK_BR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_BR :: DISABLE => false , LOCK_BR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_BR { match value { false => LOCK_BR :: DISABLE , i => LOCK_BR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_BR :: DISABLE } } # [ doc = "Possible values of the field `LOCK_IF_L`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IF_LR { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IF_LR :: CHUNK => false , LOCK_IF_LR :: BUFFER => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IF_LR { match value { false => LOCK_IF_LR :: CHUNK , true => LOCK_IF_LR :: BUFFER , } } # [ doc = "Checks if the value of the field is `CHUNK`" ] # [ inline ] pub fn is_chunk ( & self ) -> bool { * self == LOCK_IF_LR :: CHUNK } # [ doc = "Checks if the value of the field is `BUFFER`" ] # [ inline ] pub fn is_buffer ( & self ) -> bool { * self == LOCK_IF_LR :: BUFFER } } # [ doc = r" Value of the field" ] pub struct AHB_PROTR { bits : u8 , } impl AHB_PROTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FIFOCFG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FIFOCFGR { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FIFOCFGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FIFOCFGR :: ALAP_CFG => 0 , FIFOCFGR :: HALF_CFG => 0x01 , FIFOCFGR :: ASAP_CFG => 0x02 , FIFOCFGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FIFOCFGR { match value { 0 => FIFOCFGR :: ALAP_CFG , 1 => FIFOCFGR :: HALF_CFG , 2 => FIFOCFGR :: ASAP_CFG , i => FIFOCFGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ALAP_CFG`" ] # [ inline ] pub fn is_alap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ALAP_CFG } # [ doc = "Checks if the value of the field is `HALF_CFG`" ] # [ inline ] pub fn is_half_cfg ( & self ) -> bool { * self == FIFOCFGR :: HALF_CFG } # [ doc = "Checks if the value of the field is `ASAP_CFG`" ] # [ inline ] pub fn is_asap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ASAP_CFG } } # [ doc = r" Proxy" ] pub struct _SRC_PERW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_PERW < '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 } } # [ doc = r" Proxy" ] pub struct _DST_PERW < 'a > { w : & 'a mut W , } impl < 'a > _DST_PERW < '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 = "Values that can be written to the field `SRC_H2SEL`" ] pub enum SRC_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_H2SELW :: SW => false , SRC_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _SRC_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_H2SEL`" ] pub enum DST_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_H2SELW :: SW => false , DST_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _DST_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _DST_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SOD`" ] pub enum SODW { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SODW :: DISABLE => false , SODW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SODW < 'a > { w : & 'a mut W , } impl < 'a > _SODW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SODW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( SODW :: DISABLE ) } # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SODW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF`" ] pub enum LOCK_IFW { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IFW :: DISABLE => false , LOCK_IFW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IFW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IFW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Interface Lock capability is disabled" ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: DISABLE ) } # [ doc = "Interface Lock capability is enabled" ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_B`" ] pub enum LOCK_BW { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE } impl LOCK_BW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_BW :: DISABLE => false } } } # [ doc = r" Proxy" ] pub struct _LOCK_BW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_BW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_BW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "AHB Bus Locking capability is disabled." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_BW :: DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF_L`" ] pub enum LOCK_IF_LW { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IF_LW :: CHUNK => false , LOCK_IF_LW :: BUFFER => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IF_LW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IF_LW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IF_LW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] # [ inline ] pub fn chunk ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: CHUNK ) } # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] # [ inline ] pub fn buffer ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: BUFFER ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AHB_PROTW < 'a > { w : & 'a mut W , } impl < 'a > _AHB_PROTW < '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 = "Values that can be written to the field `FIFOCFG`" ] pub enum FIFOCFGW { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG } impl FIFOCFGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FIFOCFGW :: ALAP_CFG => 0 , FIFOCFGW :: HALF_CFG => 1 , FIFOCFGW :: ASAP_CFG => 2 } } } # [ doc = r" Proxy" ] pub struct _FIFOCFGW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCFGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FIFOCFGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] # [ inline ] pub fn alap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ALAP_CFG ) } # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] # [ inline ] pub fn half_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: HALF_CFG ) } # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] # [ inline ] pub fn asap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ASAP_CFG ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & self ) -> SRC_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SRC_PERR { bits } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & self ) -> DST_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DST_PERR { bits } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & self ) -> SRC_H2SELR { SRC_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & self ) -> DST_H2SELR { DST_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & self ) -> SODR { SODR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & self ) -> LOCK_IFR { LOCK_IFR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & self ) -> LOCK_BR { LOCK_BR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & self ) -> LOCK_IF_LR { LOCK_IF_LR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & self ) -> AHB_PROTR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; AHB_PROTR { bits } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & self ) -> FIFOCFGR { FIFOCFGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100_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 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & mut self ) -> _SRC_PERW { _SRC_PERW { w : self } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & mut self ) -> _DST_PERW { _DST_PERW { w : self } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & mut self ) -> _SRC_H2SELW { _SRC_H2SELW { w : self } } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & mut self ) -> _DST_H2SELW { _DST_H2SELW { w : self } } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & mut self ) -> _SODW { _SODW { w : self } } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & mut self ) -> _LOCK_IFW { _LOCK_IFW { w : self } } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & mut self ) -> _LOCK_BW { _LOCK_BW { w : self } } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & mut self ) -> _LOCK_IF_LW { _LOCK_IF_LW { w : self } } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & mut self ) -> _AHB_PROTW { _AHB_PROTW { w : self } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & mut self ) -> _FIFOCFGW { _FIFOCFGW { w : self } } } } # [ doc = "DMAC Channel Source Address Register (ch_num = 4)" ] pub struct SADDR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Source Address Register (ch_num = 4)" ] pub mod saddr4 { # [ 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 :: SADDR4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADDRR { bits : u32 , } impl SADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADDRW < 'a > { w : & 'a mut W , } impl < 'a > _SADDRW < '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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & self ) -> SADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; SADDRR { 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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & mut self ) -> _SADDRW { _SADDRW { w : self } } } } # [ doc = "DMAC Channel Destination Address Register (ch_num = 4)" ] pub struct DADDR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Destination Address Register (ch_num = 4)" ] pub mod daddr4 { # [ 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 :: DADDR4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DADDRR { bits : u32 , } impl DADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DADDRW < 'a > { w : & 'a mut W , } impl < 'a > _DADDRW < '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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & self ) -> DADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DADDRR { 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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & mut self ) -> _DADDRW { _DADDRW { w : self } } } } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 4)" ] pub struct DSCR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 4)" ] pub mod dscr4 { # [ 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 :: DSCR4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DSCRR { bits : u32 , } impl DSCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DSCRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & self ) -> DSCRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DSCRR { 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 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & mut self ) -> _DSCRW { _DSCRW { w : self } } } } # [ doc = "DMAC Channel Control A Register (ch_num = 4)" ] pub struct CTRLA4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control A Register (ch_num = 4)" ] pub mod ctrla4 { # [ 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 :: CTRLA4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BTSIZER { bits : u16 , } impl BTSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = "Possible values of the field `SCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SCSIZER :: CHK_1 => 0 , SCSIZER :: CHK_4 => 0x01 , SCSIZER :: CHK_8 => 0x02 , SCSIZER :: CHK_16 => 0x03 , SCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SCSIZER { match value { 0 => SCSIZER :: CHK_1 , 1 => SCSIZER :: CHK_4 , 2 => SCSIZER :: CHK_8 , 3 => SCSIZER :: CHK_16 , i => SCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == SCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == SCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == SCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == SCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `DCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DCSIZER :: CHK_1 => 0 , DCSIZER :: CHK_4 => 0x01 , DCSIZER :: CHK_8 => 0x02 , DCSIZER :: CHK_16 => 0x03 , DCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DCSIZER { match value { 0 => DCSIZER :: CHK_1 , 1 => DCSIZER :: CHK_4 , 2 => DCSIZER :: CHK_8 , 3 => DCSIZER :: CHK_16 , i => DCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == DCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == DCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == DCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == DCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `SRC_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_WIDTHR :: BYTE => 0 , SRC_WIDTHR :: HALF_WORD => 0x01 , SRC_WIDTHR :: WORD => 0x02 , SRC_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_WIDTHR { match value { 0 => SRC_WIDTHR :: BYTE , 1 => SRC_WIDTHR :: HALF_WORD , 2 => SRC_WIDTHR :: WORD , i => SRC_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == SRC_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == SRC_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == SRC_WIDTHR :: WORD } } # [ doc = "Possible values of the field `DST_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_WIDTHR :: BYTE => 0 , DST_WIDTHR :: HALF_WORD => 0x01 , DST_WIDTHR :: WORD => 0x02 , DST_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_WIDTHR { match value { 0 => DST_WIDTHR :: BYTE , 1 => DST_WIDTHR :: HALF_WORD , 2 => DST_WIDTHR :: WORD , i => DST_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == DST_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == DST_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == DST_WIDTHR :: WORD } } # [ doc = r" Value of the field" ] pub struct DONER { bits : bool , } impl DONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _BTSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _BTSIZEW < '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 } } # [ doc = "Values that can be written to the field `SCSIZE`" ] pub enum SCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl SCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SCSIZEW :: CHK_1 => 0 , SCSIZEW :: CHK_4 => 1 , SCSIZEW :: CHK_8 => 2 , SCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _SCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _SCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_16 ) } # [ 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `DCSIZE`" ] pub enum DCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl DCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DCSIZEW :: CHK_1 => 0 , DCSIZEW :: CHK_4 => 1 , DCSIZEW :: CHK_8 => 2 , DCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _DCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _DCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_16 ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `SRC_WIDTH`" ] pub enum SRC_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl SRC_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_WIDTHW :: BYTE => 0 , SRC_WIDTHW :: HALF_WORD => 1 , SRC_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: WORD ) } # [ 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 = "Values that can be written to the field `DST_WIDTH`" ] pub enum DST_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl DST_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_WIDTHW :: BYTE => 0 , DST_WIDTHW :: HALF_WORD => 1 , DST_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _DST_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: WORD ) } # [ 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 _DONEW < 'a > { w : & 'a mut W , } impl < 'a > _DONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:15 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & self ) -> BTSIZER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BTSIZER { bits } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & self ) -> SCSIZER { SCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & self ) -> DCSIZER { DCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & self ) -> SRC_WIDTHR { SRC_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & self ) -> DST_WIDTHR { DST_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & self ) -> DONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DONER { 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 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & mut self ) -> _BTSIZEW { _BTSIZEW { w : self } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & mut self ) -> _SCSIZEW { _SCSIZEW { w : self } } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & mut self ) -> _DCSIZEW { _DCSIZEW { w : self } } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & mut self ) -> _SRC_WIDTHW { _SRC_WIDTHW { w : self } } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & mut self ) -> _DST_WIDTHW { _DST_WIDTHW { w : self } } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & mut self ) -> _DONEW { _DONEW { w : self } } } } # [ doc = "DMAC Channel Control B Register (ch_num = 4)" ] pub struct CTRLB4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control B Register (ch_num = 4)" ] pub mod ctrlb4 { # [ 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 :: CTRLB4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `SRC_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_DSCRR { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_DSCRR :: FETCH_FROM_MEM => false , SRC_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_DSCRR { match value { false => SRC_DSCRR :: FETCH_FROM_MEM , true => SRC_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `DST_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_DSCRR { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_DSCRR :: FETCH_FROM_MEM => false , DST_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_DSCRR { match value { false => DST_DSCRR :: FETCH_FROM_MEM , true => DST_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == DST_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == DST_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `FC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FCR { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FCR :: MEM2MEM_DMA_FC => 0 , FCR :: MEM2PER_DMA_FC => 0x01 , FCR :: PER2MEM_DMA_FC => 0x02 , FCR :: PER2PER_DMA_FC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FCR { match value { 0 => FCR :: MEM2MEM_DMA_FC , 1 => FCR :: MEM2PER_DMA_FC , 2 => FCR :: PER2MEM_DMA_FC , 3 => FCR :: PER2PER_DMA_FC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MEM2MEM_DMA_FC`" ] # [ inline ] pub fn is_mem2mem_dma_fc ( & self ) -> bool { * self == FCR :: MEM2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `MEM2PER_DMA_FC`" ] # [ inline ] pub fn is_mem2per_dma_fc ( & self ) -> bool { * self == FCR :: MEM2PER_DMA_FC } # [ doc = "Checks if the value of the field is `PER2MEM_DMA_FC`" ] # [ inline ] pub fn is_per2mem_dma_fc ( & self ) -> bool { * self == FCR :: PER2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `PER2PER_DMA_FC`" ] # [ inline ] pub fn is_per2per_dma_fc ( & self ) -> bool { * self == FCR :: PER2PER_DMA_FC } } # [ doc = "Possible values of the field `SRC_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_INCRR { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_INCRR :: INCREMENTING => 0 , SRC_INCRR :: DECREMENTING => 0x01 , SRC_INCRR :: FIXED => 0x02 , SRC_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_INCRR { match value { 0 => SRC_INCRR :: INCREMENTING , 1 => SRC_INCRR :: DECREMENTING , 2 => SRC_INCRR :: FIXED , i => SRC_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == SRC_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == SRC_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == SRC_INCRR :: FIXED } } # [ doc = "Possible values of the field `DST_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_INCRR { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_INCRR :: INCREMENTING => 0 , DST_INCRR :: DECREMENTING => 0x01 , DST_INCRR :: FIXED => 0x02 , DST_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_INCRR { match value { 0 => DST_INCRR :: INCREMENTING , 1 => DST_INCRR :: DECREMENTING , 2 => DST_INCRR :: FIXED , i => DST_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == DST_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == DST_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == DST_INCRR :: FIXED } } # [ doc = r" Value of the field" ] pub struct IENR { bits : bool , } impl IENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `SRC_DSCR`" ] pub enum SRC_DSCRW { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_DSCRW :: FETCH_FROM_MEM => false , SRC_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _SRC_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_DSCR`" ] pub enum DST_DSCRW { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_DSCRW :: FETCH_FROM_MEM => false , DST_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _DST_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FC`" ] pub enum FCW { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCW :: MEM2MEM_DMA_FC => 0 , FCW :: MEM2PER_DMA_FC => 1 , FCW :: PER2MEM_DMA_FC => 2 , FCW :: PER2PER_DMA_FC => 3 } } } # [ doc = r" Proxy" ] pub struct _FCW < 'a > { w : & 'a mut W , } impl < 'a > _FCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2MEM_DMA_FC ) } # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2PER_DMA_FC ) } # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn per2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2MEM_DMA_FC ) } # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn per2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2PER_DMA_FC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SRC_INCR`" ] pub enum SRC_INCRW { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED } impl SRC_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_INCRW :: INCREMENTING => 0 , SRC_INCRW :: DECREMENTING => 1 , SRC_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The source address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: INCREMENTING ) } # [ doc = "The source address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: DECREMENTING ) } # [ doc = "The source address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: FIXED ) } # [ 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 = "Values that can be written to the field `DST_INCR`" ] pub enum DST_INCRW { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED } impl DST_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_INCRW :: INCREMENTING => 0 , DST_INCRW :: DECREMENTING => 1 , DST_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The destination address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: INCREMENTING ) } # [ doc = "The destination address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: DECREMENTING ) } # [ doc = "The destination address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: FIXED ) } # [ 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 _IENW < 'a > { w : & 'a mut W , } impl < 'a > _IENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 16 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & self ) -> SRC_DSCRR { SRC_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & self ) -> DST_DSCRR { DST_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & self ) -> FCR { FCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & self ) -> SRC_INCRR { SRC_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & self ) -> DST_INCRR { DST_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & self ) -> IENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IENR { 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 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & mut self ) -> _SRC_DSCRW { _SRC_DSCRW { w : self } } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & mut self ) -> _DST_DSCRW { _DST_DSCRW { w : self } } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & mut self ) -> _FCW { _FCW { w : self } } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & mut self ) -> _SRC_INCRW { _SRC_INCRW { w : self } } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & mut self ) -> _DST_INCRW { _DST_INCRW { w : self } } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & mut self ) -> _IENW { _IENW { w : self } } } } # [ doc = "DMAC Channel Configuration Register (ch_num = 4)" ] pub struct CFG4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Configuration Register (ch_num = 4)" ] pub mod cfg4 { # [ 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 :: CFG4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SRC_PERR { bits : u8 , } impl SRC_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DST_PERR { bits : u8 , } impl DST_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SRC_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_H2SELR :: SW => false , SRC_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_H2SELR { match value { false => SRC_H2SELR :: SW , true => SRC_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == SRC_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == SRC_H2SELR :: HW } } # [ doc = "Possible values of the field `DST_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_H2SELR :: SW => false , DST_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_H2SELR { match value { false => DST_H2SELR :: SW , true => DST_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == DST_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == DST_H2SELR :: HW } } # [ doc = "Possible values of the field `SOD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SODR { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SODR :: DISABLE => false , SODR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SODR { match value { false => SODR :: DISABLE , true => SODR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == SODR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SODR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_IF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IFR { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IFR :: DISABLE => false , LOCK_IFR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IFR { match value { false => LOCK_IFR :: DISABLE , true => LOCK_IFR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_IFR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == LOCK_IFR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_B`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_BR { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE , # [ doc = r" Reserved" ] _Reserved ( bool ) } impl LOCK_BR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_BR :: DISABLE => false , LOCK_BR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_BR { match value { false => LOCK_BR :: DISABLE , i => LOCK_BR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_BR :: DISABLE } } # [ doc = "Possible values of the field `LOCK_IF_L`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IF_LR { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IF_LR :: CHUNK => false , LOCK_IF_LR :: BUFFER => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IF_LR { match value { false => LOCK_IF_LR :: CHUNK , true => LOCK_IF_LR :: BUFFER , } } # [ doc = "Checks if the value of the field is `CHUNK`" ] # [ inline ] pub fn is_chunk ( & self ) -> bool { * self == LOCK_IF_LR :: CHUNK } # [ doc = "Checks if the value of the field is `BUFFER`" ] # [ inline ] pub fn is_buffer ( & self ) -> bool { * self == LOCK_IF_LR :: BUFFER } } # [ doc = r" Value of the field" ] pub struct AHB_PROTR { bits : u8 , } impl AHB_PROTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FIFOCFG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FIFOCFGR { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FIFOCFGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FIFOCFGR :: ALAP_CFG => 0 , FIFOCFGR :: HALF_CFG => 0x01 , FIFOCFGR :: ASAP_CFG => 0x02 , FIFOCFGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FIFOCFGR { match value { 0 => FIFOCFGR :: ALAP_CFG , 1 => FIFOCFGR :: HALF_CFG , 2 => FIFOCFGR :: ASAP_CFG , i => FIFOCFGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ALAP_CFG`" ] # [ inline ] pub fn is_alap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ALAP_CFG } # [ doc = "Checks if the value of the field is `HALF_CFG`" ] # [ inline ] pub fn is_half_cfg ( & self ) -> bool { * self == FIFOCFGR :: HALF_CFG } # [ doc = "Checks if the value of the field is `ASAP_CFG`" ] # [ inline ] pub fn is_asap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ASAP_CFG } } # [ doc = r" Proxy" ] pub struct _SRC_PERW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_PERW < '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 } } # [ doc = r" Proxy" ] pub struct _DST_PERW < 'a > { w : & 'a mut W , } impl < 'a > _DST_PERW < '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 = "Values that can be written to the field `SRC_H2SEL`" ] pub enum SRC_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_H2SELW :: SW => false , SRC_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _SRC_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_H2SEL`" ] pub enum DST_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_H2SELW :: SW => false , DST_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _DST_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _DST_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SOD`" ] pub enum SODW { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SODW :: DISABLE => false , SODW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SODW < 'a > { w : & 'a mut W , } impl < 'a > _SODW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SODW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( SODW :: DISABLE ) } # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SODW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF`" ] pub enum LOCK_IFW { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IFW :: DISABLE => false , LOCK_IFW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IFW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IFW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Interface Lock capability is disabled" ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: DISABLE ) } # [ doc = "Interface Lock capability is enabled" ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_B`" ] pub enum LOCK_BW { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE } impl LOCK_BW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_BW :: DISABLE => false } } } # [ doc = r" Proxy" ] pub struct _LOCK_BW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_BW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_BW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "AHB Bus Locking capability is disabled." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_BW :: DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF_L`" ] pub enum LOCK_IF_LW { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IF_LW :: CHUNK => false , LOCK_IF_LW :: BUFFER => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IF_LW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IF_LW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IF_LW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] # [ inline ] pub fn chunk ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: CHUNK ) } # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] # [ inline ] pub fn buffer ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: BUFFER ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AHB_PROTW < 'a > { w : & 'a mut W , } impl < 'a > _AHB_PROTW < '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 = "Values that can be written to the field `FIFOCFG`" ] pub enum FIFOCFGW { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG } impl FIFOCFGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FIFOCFGW :: ALAP_CFG => 0 , FIFOCFGW :: HALF_CFG => 1 , FIFOCFGW :: ASAP_CFG => 2 } } } # [ doc = r" Proxy" ] pub struct _FIFOCFGW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCFGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FIFOCFGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] # [ inline ] pub fn alap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ALAP_CFG ) } # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] # [ inline ] pub fn half_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: HALF_CFG ) } # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] # [ inline ] pub fn asap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ASAP_CFG ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & self ) -> SRC_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SRC_PERR { bits } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & self ) -> DST_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DST_PERR { bits } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & self ) -> SRC_H2SELR { SRC_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & self ) -> DST_H2SELR { DST_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & self ) -> SODR { SODR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & self ) -> LOCK_IFR { LOCK_IFR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & self ) -> LOCK_BR { LOCK_BR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & self ) -> LOCK_IF_LR { LOCK_IF_LR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & self ) -> AHB_PROTR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; AHB_PROTR { bits } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & self ) -> FIFOCFGR { FIFOCFGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100_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 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & mut self ) -> _SRC_PERW { _SRC_PERW { w : self } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & mut self ) -> _DST_PERW { _DST_PERW { w : self } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & mut self ) -> _SRC_H2SELW { _SRC_H2SELW { w : self } } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & mut self ) -> _DST_H2SELW { _DST_H2SELW { w : self } } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & mut self ) -> _SODW { _SODW { w : self } } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & mut self ) -> _LOCK_IFW { _LOCK_IFW { w : self } } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & mut self ) -> _LOCK_BW { _LOCK_BW { w : self } } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & mut self ) -> _LOCK_IF_LW { _LOCK_IF_LW { w : self } } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & mut self ) -> _AHB_PROTW { _AHB_PROTW { w : self } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & mut self ) -> _FIFOCFGW { _FIFOCFGW { w : self } } } } # [ doc = "DMAC Channel Source Address Register (ch_num = 5)" ] pub struct SADDR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Source Address Register (ch_num = 5)" ] pub mod saddr5 { # [ 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 :: SADDR5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SADDRR { bits : u32 , } impl SADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _SADDRW < 'a > { w : & 'a mut W , } impl < 'a > _SADDRW < '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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & self ) -> SADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; SADDRR { 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 - Channel x Source Address" ] # [ inline ] pub fn saddr ( & mut self ) -> _SADDRW { _SADDRW { w : self } } } } # [ doc = "DMAC Channel Destination Address Register (ch_num = 5)" ] pub struct DADDR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Destination Address Register (ch_num = 5)" ] pub mod daddr5 { # [ 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 :: DADDR5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DADDRR { bits : u32 , } impl DADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DADDRW < 'a > { w : & 'a mut W , } impl < 'a > _DADDRW < '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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & self ) -> DADDRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DADDRR { 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 - Channel x Destination Address" ] # [ inline ] pub fn daddr ( & mut self ) -> _DADDRW { _DADDRW { w : self } } } } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 5)" ] pub struct DSCR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Descriptor Address Register (ch_num = 5)" ] pub mod dscr5 { # [ 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 :: DSCR5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DSCRR { bits : u32 , } impl DSCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DSCRW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u32 ) -> & 'a mut W { const MASK : u32 = 0x3fff_ffff ; 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 = "Bits 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & self ) -> DSCRR { let bits = { const MASK : u32 = 0x3fff_ffff ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; DSCRR { 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 2:31 - Buffer Transfer Descriptor Address" ] # [ inline ] pub fn dscr ( & mut self ) -> _DSCRW { _DSCRW { w : self } } } } # [ doc = "DMAC Channel Control A Register (ch_num = 5)" ] pub struct CTRLA5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control A Register (ch_num = 5)" ] pub mod ctrla5 { # [ 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 :: CTRLA5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BTSIZER { bits : u16 , } impl BTSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = "Possible values of the field `SCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SCSIZER :: CHK_1 => 0 , SCSIZER :: CHK_4 => 0x01 , SCSIZER :: CHK_8 => 0x02 , SCSIZER :: CHK_16 => 0x03 , SCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SCSIZER { match value { 0 => SCSIZER :: CHK_1 , 1 => SCSIZER :: CHK_4 , 2 => SCSIZER :: CHK_8 , 3 => SCSIZER :: CHK_16 , i => SCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == SCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == SCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == SCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == SCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `DCSIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DCSIZER { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DCSIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DCSIZER :: CHK_1 => 0 , DCSIZER :: CHK_4 => 0x01 , DCSIZER :: CHK_8 => 0x02 , DCSIZER :: CHK_16 => 0x03 , DCSIZER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DCSIZER { match value { 0 => DCSIZER :: CHK_1 , 1 => DCSIZER :: CHK_4 , 2 => DCSIZER :: CHK_8 , 3 => DCSIZER :: CHK_16 , i => DCSIZER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHK_1`" ] # [ inline ] pub fn is_chk_1 ( & self ) -> bool { * self == DCSIZER :: CHK_1 } # [ doc = "Checks if the value of the field is `CHK_4`" ] # [ inline ] pub fn is_chk_4 ( & self ) -> bool { * self == DCSIZER :: CHK_4 } # [ doc = "Checks if the value of the field is `CHK_8`" ] # [ inline ] pub fn is_chk_8 ( & self ) -> bool { * self == DCSIZER :: CHK_8 } # [ doc = "Checks if the value of the field is `CHK_16`" ] # [ inline ] pub fn is_chk_16 ( & self ) -> bool { * self == DCSIZER :: CHK_16 } } # [ doc = "Possible values of the field `SRC_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_WIDTHR :: BYTE => 0 , SRC_WIDTHR :: HALF_WORD => 0x01 , SRC_WIDTHR :: WORD => 0x02 , SRC_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_WIDTHR { match value { 0 => SRC_WIDTHR :: BYTE , 1 => SRC_WIDTHR :: HALF_WORD , 2 => SRC_WIDTHR :: WORD , i => SRC_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == SRC_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == SRC_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == SRC_WIDTHR :: WORD } } # [ doc = "Possible values of the field `DST_WIDTH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_WIDTHR { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_WIDTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_WIDTHR :: BYTE => 0 , DST_WIDTHR :: HALF_WORD => 0x01 , DST_WIDTHR :: WORD => 0x02 , DST_WIDTHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_WIDTHR { match value { 0 => DST_WIDTHR :: BYTE , 1 => DST_WIDTHR :: HALF_WORD , 2 => DST_WIDTHR :: WORD , i => DST_WIDTHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `BYTE`" ] # [ inline ] pub fn is_byte ( & self ) -> bool { * self == DST_WIDTHR :: BYTE } # [ doc = "Checks if the value of the field is `HALF_WORD`" ] # [ inline ] pub fn is_half_word ( & self ) -> bool { * self == DST_WIDTHR :: HALF_WORD } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == DST_WIDTHR :: WORD } } # [ doc = r" Value of the field" ] pub struct DONER { bits : bool , } impl DONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _BTSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _BTSIZEW < '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 } } # [ doc = "Values that can be written to the field `SCSIZE`" ] pub enum SCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl SCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SCSIZEW :: CHK_1 => 0 , SCSIZEW :: CHK_4 => 1 , SCSIZEW :: CHK_8 => 2 , SCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _SCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _SCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( SCSIZEW :: CHK_16 ) } # [ 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 = 16 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `DCSIZE`" ] pub enum DCSIZEW { # [ doc = "1 data transferred" ] CHK_1 , # [ doc = "4 data transferred" ] CHK_4 , # [ doc = "8 data transferred" ] CHK_8 , # [ doc = "16 data transferred" ] CHK_16 } impl DCSIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DCSIZEW :: CHK_1 => 0 , DCSIZEW :: CHK_4 => 1 , DCSIZEW :: CHK_8 => 2 , DCSIZEW :: CHK_16 => 3 } } } # [ doc = r" Proxy" ] pub struct _DCSIZEW < 'a > { w : & 'a mut W , } impl < 'a > _DCSIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DCSIZEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 data transferred" ] # [ inline ] pub fn chk_1 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_1 ) } # [ doc = "4 data transferred" ] # [ inline ] pub fn chk_4 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_4 ) } # [ doc = "8 data transferred" ] # [ inline ] pub fn chk_8 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_8 ) } # [ doc = "16 data transferred" ] # [ inline ] pub fn chk_16 ( self ) -> & 'a mut W { self . variant ( DCSIZEW :: CHK_16 ) } # [ 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 = 20 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `SRC_WIDTH`" ] pub enum SRC_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl SRC_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_WIDTHW :: BYTE => 0 , SRC_WIDTHW :: HALF_WORD => 1 , SRC_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( SRC_WIDTHW :: WORD ) } # [ 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 = "Values that can be written to the field `DST_WIDTH`" ] pub enum DST_WIDTHW { # [ doc = "the transfer size is set to 8-bit width" ] BYTE , # [ doc = "the transfer size is set to 16-bit width" ] HALF_WORD , # [ doc = "the transfer size is set to 32-bit width" ] WORD } impl DST_WIDTHW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_WIDTHW :: BYTE => 0 , DST_WIDTHW :: HALF_WORD => 1 , DST_WIDTHW :: WORD => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_WIDTHW < 'a > { w : & 'a mut W , } impl < 'a > _DST_WIDTHW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_WIDTHW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "the transfer size is set to 8-bit width" ] # [ inline ] pub fn byte ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: BYTE ) } # [ doc = "the transfer size is set to 16-bit width" ] # [ inline ] pub fn half_word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: HALF_WORD ) } # [ doc = "the transfer size is set to 32-bit width" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( DST_WIDTHW :: WORD ) } # [ 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 _DONEW < 'a > { w : & 'a mut W , } impl < 'a > _DONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:15 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & self ) -> BTSIZER { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; BTSIZER { bits } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & self ) -> SCSIZER { SCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & self ) -> DCSIZER { DCSIZER :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & self ) -> SRC_WIDTHR { SRC_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & self ) -> DST_WIDTHR { DST_WIDTHR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & self ) -> DONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DONER { 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 - Buffer Transfer Size" ] # [ inline ] pub fn btsize ( & mut self ) -> _BTSIZEW { _BTSIZEW { w : self } } # [ doc = "Bits 16:18 - Source Chunk Transfer Size." ] # [ inline ] pub fn scsize ( & mut self ) -> _SCSIZEW { _SCSIZEW { w : self } } # [ doc = "Bits 20:22 - Destination Chunk Transfer Size" ] # [ inline ] pub fn dcsize ( & mut self ) -> _DCSIZEW { _DCSIZEW { w : self } } # [ doc = "Bits 24:25 - Transfer Width for the Source" ] # [ inline ] pub fn src_width ( & mut self ) -> _SRC_WIDTHW { _SRC_WIDTHW { w : self } } # [ doc = "Bits 28:29 - Transfer Width for the Destination" ] # [ inline ] pub fn dst_width ( & mut self ) -> _DST_WIDTHW { _DST_WIDTHW { w : self } } # [ doc = "Bit 31 - Current Descriptor Stop Command and Transfer Completed Memory Indicator" ] # [ inline ] pub fn done ( & mut self ) -> _DONEW { _DONEW { w : self } } } } # [ doc = "DMAC Channel Control B Register (ch_num = 5)" ] pub struct CTRLB5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Control B Register (ch_num = 5)" ] pub mod ctrlb5 { # [ 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 :: CTRLB5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `SRC_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_DSCRR { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_DSCRR :: FETCH_FROM_MEM => false , SRC_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_DSCRR { match value { false => SRC_DSCRR :: FETCH_FROM_MEM , true => SRC_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == SRC_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `DST_DSCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_DSCRR { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_DSCRR :: FETCH_FROM_MEM => false , DST_DSCRR :: FETCH_DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_DSCRR { match value { false => DST_DSCRR :: FETCH_FROM_MEM , true => DST_DSCRR :: FETCH_DISABLE , } } # [ doc = "Checks if the value of the field is `FETCH_FROM_MEM`" ] # [ inline ] pub fn is_fetch_from_mem ( & self ) -> bool { * self == DST_DSCRR :: FETCH_FROM_MEM } # [ doc = "Checks if the value of the field is `FETCH_DISABLE`" ] # [ inline ] pub fn is_fetch_disable ( & self ) -> bool { * self == DST_DSCRR :: FETCH_DISABLE } } # [ doc = "Possible values of the field `FC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FCR { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FCR :: MEM2MEM_DMA_FC => 0 , FCR :: MEM2PER_DMA_FC => 0x01 , FCR :: PER2MEM_DMA_FC => 0x02 , FCR :: PER2PER_DMA_FC => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FCR { match value { 0 => FCR :: MEM2MEM_DMA_FC , 1 => FCR :: MEM2PER_DMA_FC , 2 => FCR :: PER2MEM_DMA_FC , 3 => FCR :: PER2PER_DMA_FC , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MEM2MEM_DMA_FC`" ] # [ inline ] pub fn is_mem2mem_dma_fc ( & self ) -> bool { * self == FCR :: MEM2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `MEM2PER_DMA_FC`" ] # [ inline ] pub fn is_mem2per_dma_fc ( & self ) -> bool { * self == FCR :: MEM2PER_DMA_FC } # [ doc = "Checks if the value of the field is `PER2MEM_DMA_FC`" ] # [ inline ] pub fn is_per2mem_dma_fc ( & self ) -> bool { * self == FCR :: PER2MEM_DMA_FC } # [ doc = "Checks if the value of the field is `PER2PER_DMA_FC`" ] # [ inline ] pub fn is_per2per_dma_fc ( & self ) -> bool { * self == FCR :: PER2PER_DMA_FC } } # [ doc = "Possible values of the field `SRC_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_INCRR { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SRC_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRC_INCRR :: INCREMENTING => 0 , SRC_INCRR :: DECREMENTING => 0x01 , SRC_INCRR :: FIXED => 0x02 , SRC_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRC_INCRR { match value { 0 => SRC_INCRR :: INCREMENTING , 1 => SRC_INCRR :: DECREMENTING , 2 => SRC_INCRR :: FIXED , i => SRC_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == SRC_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == SRC_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == SRC_INCRR :: FIXED } } # [ doc = "Possible values of the field `DST_INCR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_INCRR { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DST_INCRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DST_INCRR :: INCREMENTING => 0 , DST_INCRR :: DECREMENTING => 0x01 , DST_INCRR :: FIXED => 0x02 , DST_INCRR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DST_INCRR { match value { 0 => DST_INCRR :: INCREMENTING , 1 => DST_INCRR :: DECREMENTING , 2 => DST_INCRR :: FIXED , i => DST_INCRR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `INCREMENTING`" ] # [ inline ] pub fn is_incrementing ( & self ) -> bool { * self == DST_INCRR :: INCREMENTING } # [ doc = "Checks if the value of the field is `DECREMENTING`" ] # [ inline ] pub fn is_decrementing ( & self ) -> bool { * self == DST_INCRR :: DECREMENTING } # [ doc = "Checks if the value of the field is `FIXED`" ] # [ inline ] pub fn is_fixed ( & self ) -> bool { * self == DST_INCRR :: FIXED } } # [ doc = r" Value of the field" ] pub struct IENR { bits : bool , } impl IENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `SRC_DSCR`" ] pub enum SRC_DSCRW { # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] FETCH_DISABLE } impl SRC_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_DSCRW :: FETCH_FROM_MEM => false , SRC_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _SRC_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Source address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the source." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( SRC_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_DSCR`" ] pub enum DST_DSCRW { # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] FETCH_FROM_MEM , # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] FETCH_DISABLE } impl DST_DSCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_DSCRW :: FETCH_FROM_MEM => false , DST_DSCRW :: FETCH_DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _DST_DSCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_DSCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_DSCRW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Destination address is updated when the descriptor is fetched from the memory." ] # [ inline ] pub fn fetch_from_mem ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_FROM_MEM ) } # [ doc = "Buffer Descriptor Fetch operation is disabled for the destination." ] # [ inline ] pub fn fetch_disable ( self ) -> & 'a mut W { self . variant ( DST_DSCRW :: FETCH_DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FC`" ] pub enum FCW { # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] MEM2MEM_DMA_FC , # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] MEM2PER_DMA_FC , # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] PER2MEM_DMA_FC , # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] PER2PER_DMA_FC } impl FCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCW :: MEM2MEM_DMA_FC => 0 , FCW :: MEM2PER_DMA_FC => 1 , FCW :: PER2MEM_DMA_FC => 2 , FCW :: PER2PER_DMA_FC => 3 } } } # [ doc = r" Proxy" ] pub struct _FCW < 'a > { w : & 'a mut W , } impl < 'a > _FCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Memory-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2MEM_DMA_FC ) } # [ doc = "Memory-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn mem2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: MEM2PER_DMA_FC ) } # [ doc = "Peripheral-to-Memory Transfer DMAC is flow controller" ] # [ inline ] pub fn per2mem_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2MEM_DMA_FC ) } # [ doc = "Peripheral-to-Peripheral Transfer DMAC is flow controller" ] # [ inline ] pub fn per2per_dma_fc ( self ) -> & 'a mut W { self . variant ( FCW :: PER2PER_DMA_FC ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `SRC_INCR`" ] pub enum SRC_INCRW { # [ doc = "The source address is incremented" ] INCREMENTING , # [ doc = "The source address is decremented" ] DECREMENTING , # [ doc = "The source address remains unchanged" ] FIXED } impl SRC_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SRC_INCRW :: INCREMENTING => 0 , SRC_INCRW :: DECREMENTING => 1 , SRC_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _SRC_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The source address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: INCREMENTING ) } # [ doc = "The source address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: DECREMENTING ) } # [ doc = "The source address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( SRC_INCRW :: FIXED ) } # [ 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 = "Values that can be written to the field `DST_INCR`" ] pub enum DST_INCRW { # [ doc = "The destination address is incremented" ] INCREMENTING , # [ doc = "The destination address is decremented" ] DECREMENTING , # [ doc = "The destination address remains unchanged" ] FIXED } impl DST_INCRW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DST_INCRW :: INCREMENTING => 0 , DST_INCRW :: DECREMENTING => 1 , DST_INCRW :: FIXED => 2 } } } # [ doc = r" Proxy" ] pub struct _DST_INCRW < 'a > { w : & 'a mut W , } impl < 'a > _DST_INCRW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_INCRW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The destination address is incremented" ] # [ inline ] pub fn incrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: INCREMENTING ) } # [ doc = "The destination address is decremented" ] # [ inline ] pub fn decrementing ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: DECREMENTING ) } # [ doc = "The destination address remains unchanged" ] # [ inline ] pub fn fixed ( self ) -> & 'a mut W { self . variant ( DST_INCRW :: FIXED ) } # [ 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 _IENW < 'a > { w : & 'a mut W , } impl < 'a > _IENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 16 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & self ) -> SRC_DSCRR { SRC_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & self ) -> DST_DSCRR { DST_DSCRR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & self ) -> FCR { FCR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & self ) -> SRC_INCRR { SRC_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & self ) -> DST_INCRR { DST_INCRR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & self ) -> IENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; IENR { 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 - Source Address Descriptor" ] # [ inline ] pub fn src_dscr ( & mut self ) -> _SRC_DSCRW { _SRC_DSCRW { w : self } } # [ doc = "Bit 20 - Destination Address Descriptor" ] # [ inline ] pub fn dst_dscr ( & mut self ) -> _DST_DSCRW { _DST_DSCRW { w : self } } # [ doc = "Bits 21:22 - Flow Control" ] # [ inline ] pub fn fc ( & mut self ) -> _FCW { _FCW { w : self } } # [ doc = "Bits 24:25 - Incrementing, Decrementing or Fixed Address for the Source" ] # [ inline ] pub fn src_incr ( & mut self ) -> _SRC_INCRW { _SRC_INCRW { w : self } } # [ doc = "Bits 28:29 - Incrementing, Decrementing or Fixed Address for the Destination" ] # [ inline ] pub fn dst_incr ( & mut self ) -> _DST_INCRW { _DST_INCRW { w : self } } # [ doc = "Bit 30 - Interrupt Enable Not" ] # [ inline ] pub fn ien ( & mut self ) -> _IENW { _IENW { w : self } } } } # [ doc = "DMAC Channel Configuration Register (ch_num = 5)" ] pub struct CFG5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Channel Configuration Register (ch_num = 5)" ] pub mod cfg5 { # [ 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 :: CFG5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SRC_PERR { bits : u8 , } impl SRC_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DST_PERR { bits : u8 , } impl DST_PERR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SRC_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRC_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SRC_H2SELR :: SW => false , SRC_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SRC_H2SELR { match value { false => SRC_H2SELR :: SW , true => SRC_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == SRC_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == SRC_H2SELR :: HW } } # [ doc = "Possible values of the field `DST_H2SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DST_H2SELR { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DST_H2SELR :: SW => false , DST_H2SELR :: HW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DST_H2SELR { match value { false => DST_H2SELR :: SW , true => DST_H2SELR :: HW , } } # [ doc = "Checks if the value of the field is `SW`" ] # [ inline ] pub fn is_sw ( & self ) -> bool { * self == DST_H2SELR :: SW } # [ doc = "Checks if the value of the field is `HW`" ] # [ inline ] pub fn is_hw ( & self ) -> bool { * self == DST_H2SELR :: HW } } # [ doc = "Possible values of the field `SOD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SODR { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SODR :: DISABLE => false , SODR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SODR { match value { false => SODR :: DISABLE , true => SODR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == SODR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SODR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_IF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IFR { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IFR :: DISABLE => false , LOCK_IFR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IFR { match value { false => LOCK_IFR :: DISABLE , true => LOCK_IFR :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_IFR :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == LOCK_IFR :: ENABLE } } # [ doc = "Possible values of the field `LOCK_B`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_BR { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE , # [ doc = r" Reserved" ] _Reserved ( bool ) } impl LOCK_BR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_BR :: DISABLE => false , LOCK_BR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_BR { match value { false => LOCK_BR :: DISABLE , i => LOCK_BR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == LOCK_BR :: DISABLE } } # [ doc = "Possible values of the field `LOCK_IF_L`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum LOCK_IF_LR { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { LOCK_IF_LR :: CHUNK => false , LOCK_IF_LR :: BUFFER => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> LOCK_IF_LR { match value { false => LOCK_IF_LR :: CHUNK , true => LOCK_IF_LR :: BUFFER , } } # [ doc = "Checks if the value of the field is `CHUNK`" ] # [ inline ] pub fn is_chunk ( & self ) -> bool { * self == LOCK_IF_LR :: CHUNK } # [ doc = "Checks if the value of the field is `BUFFER`" ] # [ inline ] pub fn is_buffer ( & self ) -> bool { * self == LOCK_IF_LR :: BUFFER } } # [ doc = r" Value of the field" ] pub struct AHB_PROTR { bits : u8 , } impl AHB_PROTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `FIFOCFG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FIFOCFGR { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FIFOCFGR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FIFOCFGR :: ALAP_CFG => 0 , FIFOCFGR :: HALF_CFG => 0x01 , FIFOCFGR :: ASAP_CFG => 0x02 , FIFOCFGR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FIFOCFGR { match value { 0 => FIFOCFGR :: ALAP_CFG , 1 => FIFOCFGR :: HALF_CFG , 2 => FIFOCFGR :: ASAP_CFG , i => FIFOCFGR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ALAP_CFG`" ] # [ inline ] pub fn is_alap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ALAP_CFG } # [ doc = "Checks if the value of the field is `HALF_CFG`" ] # [ inline ] pub fn is_half_cfg ( & self ) -> bool { * self == FIFOCFGR :: HALF_CFG } # [ doc = "Checks if the value of the field is `ASAP_CFG`" ] # [ inline ] pub fn is_asap_cfg ( & self ) -> bool { * self == FIFOCFGR :: ASAP_CFG } } # [ doc = r" Proxy" ] pub struct _SRC_PERW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_PERW < '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 } } # [ doc = r" Proxy" ] pub struct _DST_PERW < 'a > { w : & 'a mut W , } impl < 'a > _DST_PERW < '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 = "Values that can be written to the field `SRC_H2SEL`" ] pub enum SRC_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl SRC_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SRC_H2SELW :: SW => false , SRC_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _SRC_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _SRC_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SRC_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( SRC_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DST_H2SEL`" ] pub enum DST_H2SELW { # [ doc = "Software handshaking interface is used to trigger a transfer request." ] SW , # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] HW } impl DST_H2SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DST_H2SELW :: SW => false , DST_H2SELW :: HW => true } } } # [ doc = r" Proxy" ] pub struct _DST_H2SELW < 'a > { w : & 'a mut W , } impl < 'a > _DST_H2SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DST_H2SELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Software handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn sw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: SW ) } # [ doc = "Hardware handshaking interface is used to trigger a transfer request." ] # [ inline ] pub fn hw ( self ) -> & 'a mut W { self . variant ( DST_H2SELW :: HW ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SOD`" ] pub enum SODW { # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] DISABLE , # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] ENABLE } impl SODW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SODW :: DISABLE => false , SODW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SODW < 'a > { w : & 'a mut W , } impl < 'a > _SODW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SODW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "STOP ON DONE disabled, the descriptor fetch operation ignores DONE Field of CTRLA register." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( SODW :: DISABLE ) } # [ doc = "STOP ON DONE activated, the DMAC module is automatically disabled if DONE FIELD is set to 1." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SODW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF`" ] pub enum LOCK_IFW { # [ doc = "Interface Lock capability is disabled" ] DISABLE , # [ doc = "Interface Lock capability is enabled" ] ENABLE } impl LOCK_IFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IFW :: DISABLE => false , LOCK_IFW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IFW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IFW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Interface Lock capability is disabled" ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: DISABLE ) } # [ doc = "Interface Lock capability is enabled" ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( LOCK_IFW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_B`" ] pub enum LOCK_BW { # [ doc = "AHB Bus Locking capability is disabled." ] DISABLE } impl LOCK_BW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_BW :: DISABLE => false } } } # [ doc = r" Proxy" ] pub struct _LOCK_BW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_BW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_BW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "AHB Bus Locking capability is disabled." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( LOCK_BW :: DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `LOCK_IF_L`" ] pub enum LOCK_IF_LW { # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] CHUNK , # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] BUFFER } impl LOCK_IF_LW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { LOCK_IF_LW :: CHUNK => false , LOCK_IF_LW :: BUFFER => true } } } # [ doc = r" Proxy" ] pub struct _LOCK_IF_LW < 'a > { w : & 'a mut W , } impl < 'a > _LOCK_IF_LW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : LOCK_IF_LW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Master Interface Arbiter is locked by the channel x for a chunk transfer." ] # [ inline ] pub fn chunk ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: CHUNK ) } # [ doc = "The Master Interface Arbiter is locked by the channel x for a buffer transfer." ] # [ inline ] pub fn buffer ( self ) -> & 'a mut W { self . variant ( LOCK_IF_LW :: BUFFER ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AHB_PROTW < 'a > { w : & 'a mut W , } impl < 'a > _AHB_PROTW < '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 = "Values that can be written to the field `FIFOCFG`" ] pub enum FIFOCFGW { # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] ALAP_CFG , # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] HALF_CFG , # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] ASAP_CFG } impl FIFOCFGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FIFOCFGW :: ALAP_CFG => 0 , FIFOCFGW :: HALF_CFG => 1 , FIFOCFGW :: ASAP_CFG => 2 } } } # [ doc = r" Proxy" ] pub struct _FIFOCFGW < 'a > { w : & 'a mut W , } impl < 'a > _FIFOCFGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FIFOCFGW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The largest defined length AHB burst is performed on the destination AHB interface." ] # [ inline ] pub fn alap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ALAP_CFG ) } # [ doc = "When half FIFO size is available/filled, a source/destination request is serviced." ] # [ inline ] pub fn half_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: HALF_CFG ) } # [ doc = "When there is enough space/data available to perform a single AHB access, then the request is serviced." ] # [ inline ] pub fn asap_cfg ( self ) -> & 'a mut W { self . variant ( FIFOCFGW :: ASAP_CFG ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & self ) -> SRC_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SRC_PERR { bits } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & self ) -> DST_PERR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DST_PERR { bits } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & self ) -> SRC_H2SELR { SRC_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & self ) -> DST_H2SELR { DST_H2SELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & self ) -> SODR { SODR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & self ) -> LOCK_IFR { LOCK_IFR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & self ) -> LOCK_BR { LOCK_BR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & self ) -> LOCK_IF_LR { LOCK_IF_LR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & self ) -> AHB_PROTR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; AHB_PROTR { bits } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & self ) -> FIFOCFGR { FIFOCFGR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0100_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 0:3 - Source with Peripheral identifier" ] # [ inline ] pub fn src_per ( & mut self ) -> _SRC_PERW { _SRC_PERW { w : self } } # [ doc = "Bits 4:7 - Destination with Peripheral identifier" ] # [ inline ] pub fn dst_per ( & mut self ) -> _DST_PERW { _DST_PERW { w : self } } # [ doc = "Bit 9 - Software or Hardware Selection for the Source" ] # [ inline ] pub fn src_h2sel ( & mut self ) -> _SRC_H2SELW { _SRC_H2SELW { w : self } } # [ doc = "Bit 13 - Software or Hardware Selection for the Destination" ] # [ inline ] pub fn dst_h2sel ( & mut self ) -> _DST_H2SELW { _DST_H2SELW { w : self } } # [ doc = "Bit 16 - Stop On Done" ] # [ inline ] pub fn sod ( & mut self ) -> _SODW { _SODW { w : self } } # [ doc = "Bit 20 - Interface Lock" ] # [ inline ] pub fn lock_if ( & mut self ) -> _LOCK_IFW { _LOCK_IFW { w : self } } # [ doc = "Bit 21 - Bus Lock" ] # [ inline ] pub fn lock_b ( & mut self ) -> _LOCK_BW { _LOCK_BW { w : self } } # [ doc = "Bit 22 - Master Interface Arbiter Lock" ] # [ inline ] pub fn lock_if_l ( & mut self ) -> _LOCK_IF_LW { _LOCK_IF_LW { w : self } } # [ doc = "Bits 24:26 - AHB Protection" ] # [ inline ] pub fn ahb_prot ( & mut self ) -> _AHB_PROTW { _AHB_PROTW { w : self } } # [ doc = "Bits 28:29 - FIFO Configuration" ] # [ inline ] pub fn fifocfg ( & mut self ) -> _FIFOCFGW { _FIFOCFGW { w : self } } } } # [ doc = "DMAC Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0044_4d41 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 4476225 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 4476225 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "DMAC Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "DMAC Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } } # [ doc = "Digital-to-Analog Converter Controller" ] pub struct DACC { _marker : PhantomData < * const ( ) > } unsafe impl Send for DACC { } impl DACC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const dacc :: RegisterBlock { 0x400c_8000 as * const _ } } impl Deref for DACC { type Target = dacc :: RegisterBlock ; fn deref ( & self ) -> & dacc :: RegisterBlock { unsafe { & * DACC :: ptr ( ) } } } # [ doc = "Digital-to-Analog Converter Controller" ] pub mod dacc { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Mode Register" ] pub mr : MR , _reserved2 : [ u8 ; 8usize ] , # [ doc = "0x10 - Channel Enable Register" ] pub cher : CHER , # [ doc = "0x14 - Channel Disable Register" ] pub chdr : CHDR , # [ doc = "0x18 - Channel Status Register" ] pub chsr : CHSR , _reserved5 : [ u8 ; 4usize ] , # [ doc = "0x20 - Conversion Data Register" ] pub cdr : CDR , # [ doc = "0x24 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x28 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x2c - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x30 - Interrupt Status Register" ] pub isr : ISR , _reserved10 : [ u8 ; 96usize ] , # [ doc = "0x94 - Analog Current Register" ] pub acr : ACR , _reserved11 : [ u8 ; 76usize ] , # [ doc = "0xe4 - Write Protect Mode register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status register" ] pub wpsr : WPSR , _reserved13 : [ u8 ; 28usize ] , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , _reserved15 : [ u8 ; 8usize ] , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ 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 = 0 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } impl W { # [ doc = "Bit 0 - Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `TRGEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TRGENR { # [ doc = "External trigger mode disabled. DACC in free running mode." ] DIS , # [ doc = "External trigger mode enabled." ] EN } impl TRGENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { TRGENR :: DIS => false , TRGENR :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> TRGENR { match value { false => TRGENR :: DIS , true => TRGENR :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == TRGENR :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == TRGENR :: EN } } # [ doc = r" Value of the field" ] pub struct TRGSELR { bits : u8 , } impl TRGSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `WORD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WORDR { # [ doc = "Half-Word transfer" ] HALF , # [ doc = "Word Transfer" ] WORD } impl WORDR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WORDR :: HALF => false , WORDR :: WORD => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WORDR { match value { false => WORDR :: HALF , true => WORDR :: WORD , } } # [ doc = "Checks if the value of the field is `HALF`" ] # [ inline ] pub fn is_half ( & self ) -> bool { * self == WORDR :: HALF } # [ doc = "Checks if the value of the field is `WORD`" ] # [ inline ] pub fn is_word ( & self ) -> bool { * self == WORDR :: WORD } } # [ doc = r" Value of the field" ] pub struct SLEEPR { bits : bool , } impl SLEEPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FASTWKUPR { bits : bool , } impl FASTWKUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct REFRESHR { bits : u8 , } impl REFRESHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `USER_SEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum USER_SELR { # [ doc = "Channel 0" ] CHANNEL0 , # [ doc = "Channel 1" ] CHANNEL1 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl USER_SELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { USER_SELR :: CHANNEL0 => 0 , USER_SELR :: CHANNEL1 => 0x01 , USER_SELR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> USER_SELR { match value { 0 => USER_SELR :: CHANNEL0 , 1 => USER_SELR :: CHANNEL1 , i => USER_SELR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CHANNEL0`" ] # [ inline ] pub fn is_channel0 ( & self ) -> bool { * self == USER_SELR :: CHANNEL0 } # [ doc = "Checks if the value of the field is `CHANNEL1`" ] # [ inline ] pub fn is_channel1 ( & self ) -> bool { * self == USER_SELR :: CHANNEL1 } } # [ doc = "Possible values of the field `TAG`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TAGR { # [ doc = "Tag selection mode disabled. Using USER_SEL to select the channel for the conversion." ] DIS , # [ doc = "Tag selection mode enabled" ] EN } impl TAGR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { TAGR :: DIS => false , TAGR :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> TAGR { match value { false => TAGR :: DIS , true => TAGR :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == TAGR :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == TAGR :: EN } } # [ doc = "Possible values of the field `MAXS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MAXSR { # [ doc = "Normal Mode" ] NORMAL , # [ doc = "Max Speed Mode enabled" ] MAXIMUM } impl MAXSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { MAXSR :: NORMAL => false , MAXSR :: MAXIMUM => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> MAXSR { match value { false => MAXSR :: NORMAL , true => MAXSR :: MAXIMUM , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == MAXSR :: NORMAL } # [ doc = "Checks if the value of the field is `MAXIMUM`" ] # [ inline ] pub fn is_maximum ( & self ) -> bool { * self == MAXSR :: MAXIMUM } } # [ doc = "Possible values of the field `STARTUP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum STARTUPR { # [ doc = "0 periods of DACClock" ] _0 , # [ doc = "8 periods of DACClock" ] _8 , # [ doc = "16 periods of DACClock" ] _16 , # [ doc = "24 periods of DACClock" ] _24 , # [ doc = "64 periods of DACClock" ] _64 , # [ doc = "80 periods of DACClock" ] _80 , # [ doc = "96 periods of DACClock" ] _96 , # [ doc = "112 periods of DACClock" ] _112 , # [ doc = "512 periods of DACClock" ] _512 , # [ doc = "576 periods of DACClock" ] _576 , # [ doc = "640 periods of DACClock" ] _640 , # [ doc = "704 periods of DACClock" ] _704 , # [ doc = "768 periods of DACClock" ] _768 , # [ doc = "832 periods of DACClock" ] _832 , # [ doc = "896 periods of DACClock" ] _896 , # [ doc = "960 periods of DACClock" ] _960 , # [ doc = "1024 periods of DACClock" ] _1024 , # [ doc = "1088 periods of DACClock" ] _1088 , # [ doc = "1152 periods of DACClock" ] _1152 , # [ doc = "1216 periods of DACClock" ] _1216 , # [ doc = "1280 periods of DACClock" ] _1280 , # [ doc = "1344 periods of DACClock" ] _1344 , # [ doc = "1408 periods of DACClock" ] _1408 , # [ doc = "1472 periods of DACClock" ] _1472 , # [ doc = "1536 periods of DACClock" ] _1536 , # [ doc = "1600 periods of DACClock" ] _1600 , # [ doc = "1664 periods of DACClock" ] _1664 , # [ doc = "1728 periods of DACClock" ] _1728 , # [ doc = "1792 periods of DACClock" ] _1792 , # [ doc = "1856 periods of DACClock" ] _1856 , # [ doc = "1920 periods of DACClock" ] _1920 , # [ doc = "1984 periods of DACClock" ] _1984 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl STARTUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { STARTUPR :: _0 => 0 , STARTUPR :: _8 => 0x01 , STARTUPR :: _16 => 0x02 , STARTUPR :: _24 => 0x03 , STARTUPR :: _64 => 0x04 , STARTUPR :: _80 => 0x05 , STARTUPR :: _96 => 0x06 , STARTUPR :: _112 => 0x07 , STARTUPR :: _512 => 0x08 , STARTUPR :: _576 => 0x09 , STARTUPR :: _640 => 0x0a , STARTUPR :: _704 => 0x0b , STARTUPR :: _768 => 0x0c , STARTUPR :: _832 => 0x0d , STARTUPR :: _896 => 0x0e , STARTUPR :: _960 => 0x0f , STARTUPR :: _1024 => 0x10 , STARTUPR :: _1088 => 0x11 , STARTUPR :: _1152 => 0x12 , STARTUPR :: _1216 => 0x13 , STARTUPR :: _1280 => 0x14 , STARTUPR :: _1344 => 0x15 , STARTUPR :: _1408 => 0x16 , STARTUPR :: _1472 => 0x17 , STARTUPR :: _1536 => 0x18 , STARTUPR :: _1600 => 0x19 , STARTUPR :: _1664 => 0x1a , STARTUPR :: _1728 => 0x1b , STARTUPR :: _1792 => 0x1c , STARTUPR :: _1856 => 0x1d , STARTUPR :: _1920 => 0x1e , STARTUPR :: _1984 => 0x1f , STARTUPR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> STARTUPR { match value { 0 => STARTUPR :: _0 , 1 => STARTUPR :: _8 , 2 => STARTUPR :: _16 , 3 => STARTUPR :: _24 , 4 => STARTUPR :: _64 , 5 => STARTUPR :: _80 , 6 => STARTUPR :: _96 , 7 => STARTUPR :: _112 , 8 => STARTUPR :: _512 , 9 => STARTUPR :: _576 , 10 => STARTUPR :: _640 , 11 => STARTUPR :: _704 , 12 => STARTUPR :: _768 , 13 => STARTUPR :: _832 , 14 => STARTUPR :: _896 , 15 => STARTUPR :: _960 , 16 => STARTUPR :: _1024 , 17 => STARTUPR :: _1088 , 18 => STARTUPR :: _1152 , 19 => STARTUPR :: _1216 , 20 => STARTUPR :: _1280 , 21 => STARTUPR :: _1344 , 22 => STARTUPR :: _1408 , 23 => STARTUPR :: _1472 , 24 => STARTUPR :: _1536 , 25 => STARTUPR :: _1600 , 26 => STARTUPR :: _1664 , 27 => STARTUPR :: _1728 , 28 => STARTUPR :: _1792 , 29 => STARTUPR :: _1856 , 30 => STARTUPR :: _1920 , 31 => STARTUPR :: _1984 , i => STARTUPR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_0`" ] # [ inline ] pub fn is_0 ( & self ) -> bool { * self == STARTUPR :: _0 } # [ doc = "Checks if the value of the field is `_8`" ] # [ inline ] pub fn is_8 ( & self ) -> bool { * self == STARTUPR :: _8 } # [ doc = "Checks if the value of the field is `_16`" ] # [ inline ] pub fn is_16 ( & self ) -> bool { * self == STARTUPR :: _16 } # [ doc = "Checks if the value of the field is `_24`" ] # [ inline ] pub fn is_24 ( & self ) -> bool { * self == STARTUPR :: _24 } # [ doc = "Checks if the value of the field is `_64`" ] # [ inline ] pub fn is_64 ( & self ) -> bool { * self == STARTUPR :: _64 } # [ doc = "Checks if the value of the field is `_80`" ] # [ inline ] pub fn is_80 ( & self ) -> bool { * self == STARTUPR :: _80 } # [ doc = "Checks if the value of the field is `_96`" ] # [ inline ] pub fn is_96 ( & self ) -> bool { * self == STARTUPR :: _96 } # [ doc = "Checks if the value of the field is `_112`" ] # [ inline ] pub fn is_112 ( & self ) -> bool { * self == STARTUPR :: _112 } # [ doc = "Checks if the value of the field is `_512`" ] # [ inline ] pub fn is_512 ( & self ) -> bool { * self == STARTUPR :: _512 } # [ doc = "Checks if the value of the field is `_576`" ] # [ inline ] pub fn is_576 ( & self ) -> bool { * self == STARTUPR :: _576 } # [ doc = "Checks if the value of the field is `_640`" ] # [ inline ] pub fn is_640 ( & self ) -> bool { * self == STARTUPR :: _640 } # [ doc = "Checks if the value of the field is `_704`" ] # [ inline ] pub fn is_704 ( & self ) -> bool { * self == STARTUPR :: _704 } # [ doc = "Checks if the value of the field is `_768`" ] # [ inline ] pub fn is_768 ( & self ) -> bool { * self == STARTUPR :: _768 } # [ doc = "Checks if the value of the field is `_832`" ] # [ inline ] pub fn is_832 ( & self ) -> bool { * self == STARTUPR :: _832 } # [ doc = "Checks if the value of the field is `_896`" ] # [ inline ] pub fn is_896 ( & self ) -> bool { * self == STARTUPR :: _896 } # [ doc = "Checks if the value of the field is `_960`" ] # [ inline ] pub fn is_960 ( & self ) -> bool { * self == STARTUPR :: _960 } # [ doc = "Checks if the value of the field is `_1024`" ] # [ inline ] pub fn is_1024 ( & self ) -> bool { * self == STARTUPR :: _1024 } # [ doc = "Checks if the value of the field is `_1088`" ] # [ inline ] pub fn is_1088 ( & self ) -> bool { * self == STARTUPR :: _1088 } # [ doc = "Checks if the value of the field is `_1152`" ] # [ inline ] pub fn is_1152 ( & self ) -> bool { * self == STARTUPR :: _1152 } # [ doc = "Checks if the value of the field is `_1216`" ] # [ inline ] pub fn is_1216 ( & self ) -> bool { * self == STARTUPR :: _1216 } # [ doc = "Checks if the value of the field is `_1280`" ] # [ inline ] pub fn is_1280 ( & self ) -> bool { * self == STARTUPR :: _1280 } # [ doc = "Checks if the value of the field is `_1344`" ] # [ inline ] pub fn is_1344 ( & self ) -> bool { * self == STARTUPR :: _1344 } # [ doc = "Checks if the value of the field is `_1408`" ] # [ inline ] pub fn is_1408 ( & self ) -> bool { * self == STARTUPR :: _1408 } # [ doc = "Checks if the value of the field is `_1472`" ] # [ inline ] pub fn is_1472 ( & self ) -> bool { * self == STARTUPR :: _1472 } # [ doc = "Checks if the value of the field is `_1536`" ] # [ inline ] pub fn is_1536 ( & self ) -> bool { * self == STARTUPR :: _1536 } # [ doc = "Checks if the value of the field is `_1600`" ] # [ inline ] pub fn is_1600 ( & self ) -> bool { * self == STARTUPR :: _1600 } # [ doc = "Checks if the value of the field is `_1664`" ] # [ inline ] pub fn is_1664 ( & self ) -> bool { * self == STARTUPR :: _1664 } # [ doc = "Checks if the value of the field is `_1728`" ] # [ inline ] pub fn is_1728 ( & self ) -> bool { * self == STARTUPR :: _1728 } # [ doc = "Checks if the value of the field is `_1792`" ] # [ inline ] pub fn is_1792 ( & self ) -> bool { * self == STARTUPR :: _1792 } # [ doc = "Checks if the value of the field is `_1856`" ] # [ inline ] pub fn is_1856 ( & self ) -> bool { * self == STARTUPR :: _1856 } # [ doc = "Checks if the value of the field is `_1920`" ] # [ inline ] pub fn is_1920 ( & self ) -> bool { * self == STARTUPR :: _1920 } # [ doc = "Checks if the value of the field is `_1984`" ] # [ inline ] pub fn is_1984 ( & self ) -> bool { * self == STARTUPR :: _1984 } } # [ doc = "Values that can be written to the field `TRGEN`" ] pub enum TRGENW { # [ doc = "External trigger mode disabled. DACC in free running mode." ] DIS , # [ doc = "External trigger mode enabled." ] EN } impl TRGENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { TRGENW :: DIS => false , TRGENW :: EN => true } } } # [ doc = r" Proxy" ] pub struct _TRGENW < 'a > { w : & 'a mut W , } impl < 'a > _TRGENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TRGENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "External trigger mode disabled. DACC in free running mode." ] # [ inline ] pub fn dis ( self ) -> & 'a mut W { self . variant ( TRGENW :: DIS ) } # [ doc = "External trigger mode enabled." ] # [ inline ] pub fn en ( self ) -> & 'a mut W { self . variant ( TRGENW :: EN ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRGSELW < 'a > { w : & 'a mut W , } impl < 'a > _TRGSELW < '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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `WORD`" ] pub enum WORDW { # [ doc = "Half-Word transfer" ] HALF , # [ doc = "Word Transfer" ] WORD } impl WORDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WORDW :: HALF => false , WORDW :: WORD => true } } } # [ doc = r" Proxy" ] pub struct _WORDW < 'a > { w : & 'a mut W , } impl < 'a > _WORDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WORDW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Half-Word transfer" ] # [ inline ] pub fn half ( self ) -> & 'a mut W { self . variant ( WORDW :: HALF ) } # [ doc = "Word Transfer" ] # [ inline ] pub fn word ( self ) -> & 'a mut W { self . variant ( WORDW :: WORD ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SLEEPW < 'a > { w : & 'a mut W , } impl < 'a > _SLEEPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FASTWKUPW < 'a > { w : & 'a mut W , } impl < 'a > _FASTWKUPW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _REFRESHW < 'a > { w : & 'a mut W , } impl < 'a > _REFRESHW < '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 = "Values that can be written to the field `USER_SEL`" ] pub enum USER_SELW { # [ doc = "Channel 0" ] CHANNEL0 , # [ doc = "Channel 1" ] CHANNEL1 } impl USER_SELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { USER_SELW :: CHANNEL0 => 0 , USER_SELW :: CHANNEL1 => 1 } } } # [ doc = r" Proxy" ] pub struct _USER_SELW < 'a > { w : & 'a mut W , } impl < 'a > _USER_SELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : USER_SELW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Channel 0" ] # [ inline ] pub fn channel0 ( self ) -> & 'a mut W { self . variant ( USER_SELW :: CHANNEL0 ) } # [ doc = "Channel 1" ] # [ inline ] pub fn channel1 ( self ) -> & 'a mut W { self . variant ( USER_SELW :: CHANNEL1 ) } # [ 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 = "Values that can be written to the field `TAG`" ] pub enum TAGW { # [ doc = "Tag selection mode disabled. Using USER_SEL to select the channel for the conversion." ] DIS , # [ doc = "Tag selection mode enabled" ] EN } impl TAGW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { TAGW :: DIS => false , TAGW :: EN => true } } } # [ doc = r" Proxy" ] pub struct _TAGW < 'a > { w : & 'a mut W , } impl < 'a > _TAGW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TAGW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Tag selection mode disabled. Using USER_SEL to select the channel for the conversion." ] # [ inline ] pub fn dis ( self ) -> & 'a mut W { self . variant ( TAGW :: DIS ) } # [ doc = "Tag selection mode enabled" ] # [ inline ] pub fn en ( self ) -> & 'a mut W { self . variant ( TAGW :: EN ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `MAXS`" ] pub enum MAXSW { # [ doc = "Normal Mode" ] NORMAL , # [ doc = "Max Speed Mode enabled" ] MAXIMUM } impl MAXSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { MAXSW :: NORMAL => false , MAXSW :: MAXIMUM => true } } } # [ doc = r" Proxy" ] pub struct _MAXSW < 'a > { w : & 'a mut W , } impl < 'a > _MAXSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MAXSW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "Normal Mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( MAXSW :: NORMAL ) } # [ doc = "Max Speed Mode enabled" ] # [ inline ] pub fn maximum ( self ) -> & 'a mut W { self . variant ( MAXSW :: MAXIMUM ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `STARTUP`" ] pub enum STARTUPW { # [ doc = "0 periods of DACClock" ] _0 , # [ doc = "8 periods of DACClock" ] _8 , # [ doc = "16 periods of DACClock" ] _16 , # [ doc = "24 periods of DACClock" ] _24 , # [ doc = "64 periods of DACClock" ] _64 , # [ doc = "80 periods of DACClock" ] _80 , # [ doc = "96 periods of DACClock" ] _96 , # [ doc = "112 periods of DACClock" ] _112 , # [ doc = "512 periods of DACClock" ] _512 , # [ doc = "576 periods of DACClock" ] _576 , # [ doc = "640 periods of DACClock" ] _640 , # [ doc = "704 periods of DACClock" ] _704 , # [ doc = "768 periods of DACClock" ] _768 , # [ doc = "832 periods of DACClock" ] _832 , # [ doc = "896 periods of DACClock" ] _896 , # [ doc = "960 periods of DACClock" ] _960 , # [ doc = "1024 periods of DACClock" ] _1024 , # [ doc = "1088 periods of DACClock" ] _1088 , # [ doc = "1152 periods of DACClock" ] _1152 , # [ doc = "1216 periods of DACClock" ] _1216 , # [ doc = "1280 periods of DACClock" ] _1280 , # [ doc = "1344 periods of DACClock" ] _1344 , # [ doc = "1408 periods of DACClock" ] _1408 , # [ doc = "1472 periods of DACClock" ] _1472 , # [ doc = "1536 periods of DACClock" ] _1536 , # [ doc = "1600 periods of DACClock" ] _1600 , # [ doc = "1664 periods of DACClock" ] _1664 , # [ doc = "1728 periods of DACClock" ] _1728 , # [ doc = "1792 periods of DACClock" ] _1792 , # [ doc = "1856 periods of DACClock" ] _1856 , # [ doc = "1920 periods of DACClock" ] _1920 , # [ doc = "1984 periods of DACClock" ] _1984 } impl STARTUPW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { STARTUPW :: _0 => 0 , STARTUPW :: _8 => 1 , STARTUPW :: _16 => 2 , STARTUPW :: _24 => 3 , STARTUPW :: _64 => 4 , STARTUPW :: _80 => 5 , STARTUPW :: _96 => 6 , STARTUPW :: _112 => 7 , STARTUPW :: _512 => 8 , STARTUPW :: _576 => 9 , STARTUPW :: _640 => 10 , STARTUPW :: _704 => 11 , STARTUPW :: _768 => 12 , STARTUPW :: _832 => 13 , STARTUPW :: _896 => 14 , STARTUPW :: _960 => 15 , STARTUPW :: _1024 => 16 , STARTUPW :: _1088 => 17 , STARTUPW :: _1152 => 18 , STARTUPW :: _1216 => 19 , STARTUPW :: _1280 => 20 , STARTUPW :: _1344 => 21 , STARTUPW :: _1408 => 22 , STARTUPW :: _1472 => 23 , STARTUPW :: _1536 => 24 , STARTUPW :: _1600 => 25 , STARTUPW :: _1664 => 26 , STARTUPW :: _1728 => 27 , STARTUPW :: _1792 => 28 , STARTUPW :: _1856 => 29 , STARTUPW :: _1920 => 30 , STARTUPW :: _1984 => 31 } } } # [ doc = r" Proxy" ] pub struct _STARTUPW < 'a > { w : & 'a mut W , } impl < 'a > _STARTUPW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : STARTUPW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "0 periods of DACClock" ] # [ inline ] pub fn _0 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _0 ) } # [ doc = "8 periods of DACClock" ] # [ inline ] pub fn _8 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _8 ) } # [ doc = "16 periods of DACClock" ] # [ inline ] pub fn _16 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _16 ) } # [ doc = "24 periods of DACClock" ] # [ inline ] pub fn _24 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _24 ) } # [ doc = "64 periods of DACClock" ] # [ inline ] pub fn _64 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _64 ) } # [ doc = "80 periods of DACClock" ] # [ inline ] pub fn _80 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _80 ) } # [ doc = "96 periods of DACClock" ] # [ inline ] pub fn _96 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _96 ) } # [ doc = "112 periods of DACClock" ] # [ inline ] pub fn _112 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _112 ) } # [ doc = "512 periods of DACClock" ] # [ inline ] pub fn _512 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _512 ) } # [ doc = "576 periods of DACClock" ] # [ inline ] pub fn _576 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _576 ) } # [ doc = "640 periods of DACClock" ] # [ inline ] pub fn _640 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _640 ) } # [ doc = "704 periods of DACClock" ] # [ inline ] pub fn _704 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _704 ) } # [ doc = "768 periods of DACClock" ] # [ inline ] pub fn _768 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _768 ) } # [ doc = "832 periods of DACClock" ] # [ inline ] pub fn _832 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _832 ) } # [ doc = "896 periods of DACClock" ] # [ inline ] pub fn _896 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _896 ) } # [ doc = "960 periods of DACClock" ] # [ inline ] pub fn _960 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _960 ) } # [ doc = "1024 periods of DACClock" ] # [ inline ] pub fn _1024 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1024 ) } # [ doc = "1088 periods of DACClock" ] # [ inline ] pub fn _1088 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1088 ) } # [ doc = "1152 periods of DACClock" ] # [ inline ] pub fn _1152 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1152 ) } # [ doc = "1216 periods of DACClock" ] # [ inline ] pub fn _1216 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1216 ) } # [ doc = "1280 periods of DACClock" ] # [ inline ] pub fn _1280 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1280 ) } # [ doc = "1344 periods of DACClock" ] # [ inline ] pub fn _1344 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1344 ) } # [ doc = "1408 periods of DACClock" ] # [ inline ] pub fn _1408 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1408 ) } # [ doc = "1472 periods of DACClock" ] # [ inline ] pub fn _1472 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1472 ) } # [ doc = "1536 periods of DACClock" ] # [ inline ] pub fn _1536 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1536 ) } # [ doc = "1600 periods of DACClock" ] # [ inline ] pub fn _1600 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1600 ) } # [ doc = "1664 periods of DACClock" ] # [ inline ] pub fn _1664 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1664 ) } # [ doc = "1728 periods of DACClock" ] # [ inline ] pub fn _1728 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1728 ) } # [ doc = "1792 periods of DACClock" ] # [ inline ] pub fn _1792 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1792 ) } # [ doc = "1856 periods of DACClock" ] # [ inline ] pub fn _1856 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1856 ) } # [ doc = "1920 periods of DACClock" ] # [ inline ] pub fn _1920 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1920 ) } # [ doc = "1984 periods of DACClock" ] # [ inline ] pub fn _1984 ( self ) -> & 'a mut W { self . variant ( STARTUPW :: _1984 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 - Trigger Enable" ] # [ inline ] pub fn trgen ( & self ) -> TRGENR { TRGENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 1:3 - Trigger Selection" ] # [ inline ] pub fn trgsel ( & self ) -> TRGSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRGSELR { bits } } # [ doc = "Bit 4 - Word Transfer" ] # [ inline ] pub fn word ( & self ) -> WORDR { WORDR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 5 - Sleep Mode" ] # [ inline ] pub fn sleep ( & self ) -> SLEEPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SLEEPR { bits } } # [ doc = "Bit 6 - Fast Wake up Mode" ] # [ inline ] pub fn fastwkup ( & self ) -> FASTWKUPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FASTWKUPR { bits } } # [ doc = "Bits 8:15 - Refresh Period" ] # [ inline ] pub fn refresh ( & self ) -> REFRESHR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; REFRESHR { bits } } # [ doc = "Bits 16:17 - User Channel Selection" ] # [ inline ] pub fn user_sel ( & self ) -> USER_SELR { USER_SELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 20 - Tag Selection Mode" ] # [ inline ] pub fn tag ( & self ) -> TAGR { TAGR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Max Speed Mode" ] # [ inline ] pub fn maxs ( & self ) -> MAXSR { MAXSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:29 - Startup Time Selection" ] # [ inline ] pub fn startup ( & self ) -> STARTUPR { STARTUPR :: _from ( { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Trigger Enable" ] # [ inline ] pub fn trgen ( & mut self ) -> _TRGENW { _TRGENW { w : self } } # [ doc = "Bits 1:3 - Trigger Selection" ] # [ inline ] pub fn trgsel ( & mut self ) -> _TRGSELW { _TRGSELW { w : self } } # [ doc = "Bit 4 - Word Transfer" ] # [ inline ] pub fn word ( & mut self ) -> _WORDW { _WORDW { w : self } } # [ doc = "Bit 5 - Sleep Mode" ] # [ inline ] pub fn sleep ( & mut self ) -> _SLEEPW { _SLEEPW { w : self } } # [ doc = "Bit 6 - Fast Wake up Mode" ] # [ inline ] pub fn fastwkup ( & mut self ) -> _FASTWKUPW { _FASTWKUPW { w : self } } # [ doc = "Bits 8:15 - Refresh Period" ] # [ inline ] pub fn refresh ( & mut self ) -> _REFRESHW { _REFRESHW { w : self } } # [ doc = "Bits 16:17 - User Channel Selection" ] # [ inline ] pub fn user_sel ( & mut self ) -> _USER_SELW { _USER_SELW { w : self } } # [ doc = "Bit 20 - Tag Selection Mode" ] # [ inline ] pub fn tag ( & mut self ) -> _TAGW { _TAGW { w : self } } # [ doc = "Bit 21 - Max Speed Mode" ] # [ inline ] pub fn maxs ( & mut self ) -> _MAXSW { _MAXSW { w : self } } # [ doc = "Bits 24:29 - Startup Time Selection" ] # [ inline ] pub fn startup ( & mut self ) -> _STARTUPW { _STARTUPW { w : self } } } } # [ doc = "Channel Enable Register" ] pub struct CHER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Enable Register" ] pub mod cher { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CHER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CH0W < 'a > { w : & 'a mut W , } impl < 'a > _CH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH1W < 'a > { w : & 'a mut W , } impl < 'a > _CH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Channel 0 Enable" ] # [ inline ] pub fn ch0 ( & mut self ) -> _CH0W { _CH0W { w : self } } # [ doc = "Bit 1 - Channel 1 Enable" ] # [ inline ] pub fn ch1 ( & mut self ) -> _CH1W { _CH1W { w : self } } } } # [ doc = "Channel Disable Register" ] pub struct CHDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Disable Register" ] pub mod chdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CHDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _CH0W < 'a > { w : & 'a mut W , } impl < 'a > _CH0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CH1W < 'a > { w : & 'a mut W , } impl < 'a > _CH1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Channel 0 Disable" ] # [ inline ] pub fn ch0 ( & mut self ) -> _CH0W { _CH0W { w : self } } # [ doc = "Bit 1 - Channel 1 Disable" ] # [ inline ] pub fn ch1 ( & mut self ) -> _CH1W { _CH1W { w : self } } } } # [ doc = "Channel Status Register" ] pub struct CHSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Channel Status Register" ] pub mod chsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CHSR { # [ 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 CH0R { bits : bool , } impl CH0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CH1R { bits : bool , } impl CH1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0 Status" ] # [ inline ] pub fn ch0 ( & self ) -> CH0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH0R { bits } } # [ doc = "Bit 1 - Channel 1 Status" ] # [ inline ] pub fn ch1 ( & self ) -> CH1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CH1R { bits } } } } # [ doc = "Conversion Data Register" ] pub struct CDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Conversion Data Register" ] pub mod cdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _DATAW < 'a > { w : & 'a mut W , } impl < 'a > _DATAW < '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 - Data to Convert" ] # [ inline ] pub fn data ( & mut self ) -> _DATAW { _DATAW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Transmit Ready Interrupt Enable" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 1 - End of Conversion Interrupt Enable" ] # [ inline ] pub fn eoc ( & mut self ) -> _EOCW { _EOCW { w : self } } # [ doc = "Bit 2 - End of Transmit Buffer Interrupt Enable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 3 - Transmit Buffer Empty Interrupt Enable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 1 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Transmit Ready Interrupt Disable." ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 1 - End of Conversion Interrupt Disable" ] # [ inline ] pub fn eoc ( & mut self ) -> _EOCW { _EOCW { w : self } } # [ doc = "Bit 2 - End of Transmit Buffer Interrupt Disable" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 3 - Transmit Buffer Empty Interrupt Disable" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmit Ready Interrupt Mask" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 1 - End of Conversion Interrupt Mask" ] # [ inline ] pub fn eoc ( & self ) -> EOCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOCR { bits } } # [ doc = "Bit 2 - End of Transmit Buffer Interrupt Mask" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 3 - Transmit Buffer Empty Interrupt Mask" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ 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 TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` 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 ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Transmit Ready Interrupt Flag" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 1 - End of Conversion Interrupt Flag" ] # [ inline ] pub fn eoc ( & self ) -> EOCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EOCR { bits } } # [ doc = "Bit 2 - End of DMA Interrupt Flag" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 3 - Transmit Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } } } # [ doc = "Analog Current Register" ] pub struct ACR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Analog Current 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 < F > ( & 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 < F > ( & 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 IBCTLCH0R { bits : u8 , } impl IBCTLCH0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct IBCTLCH1R { bits : u8 , } impl IBCTLCH1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct IBCTLDACCORER { bits : u8 , } impl IBCTLDACCORER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _IBCTLCH0W < 'a > { w : & 'a mut W , } impl < 'a > _IBCTLCH0W < '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 _IBCTLCH1W < 'a > { w : & 'a mut W , } impl < 'a > _IBCTLCH1W < '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 _IBCTLDACCOREW < 'a > { w : & 'a mut W , } impl < 'a > _IBCTLDACCOREW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Analog Output Current Control" ] # [ inline ] pub fn ibctlch0 ( & self ) -> IBCTLCH0R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IBCTLCH0R { bits } } # [ doc = "Bits 2:3 - Analog Output Current Control" ] # [ inline ] pub fn ibctlch1 ( & self ) -> IBCTLCH1R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IBCTLCH1R { bits } } # [ doc = "Bits 8:9 - Bias Current Control for DAC Core" ] # [ inline ] pub fn ibctldaccore ( & self ) -> IBCTLDACCORER { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; IBCTLDACCORER { 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 - Analog Output Current Control" ] # [ inline ] pub fn ibctlch0 ( & mut self ) -> _IBCTLCH0W { _IBCTLCH0W { w : self } } # [ doc = "Bits 2:3 - Analog Output Current Control" ] # [ inline ] pub fn ibctlch1 ( & mut self ) -> _IBCTLCH1W { _IBCTLCH1W { w : self } } # [ doc = "Bits 8:9 - Bias Current Control for DAC Core" ] # [ inline ] pub fn ibctldaccore ( & mut self ) -> _IBCTLDACCOREW { _IBCTLDACCOREW { w : self } } } } # [ doc = "Write Protect Mode register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPROTERRR { bits : bool , } impl WPROTERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPROTADDRR { bits : u8 , } impl WPROTADDRR { # [ 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 0 - Write protection error" ] # [ inline ] pub fn wproterr ( & self ) -> WPROTERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPROTERRR { bits } } # [ doc = "Bits 8:15 - Write protection error address" ] # [ inline ] pub fn wprotaddr ( & self ) -> WPROTADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WPROTADDRR { bits } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Static Memory Controller" ] pub struct SMC { _marker : PhantomData < * const ( ) > } unsafe impl Send for SMC { } impl SMC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const smc :: RegisterBlock { 0x400e_0000 as * const _ } } impl Deref for SMC { type Target = smc :: RegisterBlock ; fn deref ( & self ) -> & smc :: RegisterBlock { unsafe { & * SMC :: ptr ( ) } } } # [ doc = "Static Memory Controller" ] pub mod smc { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - SMC NFC Configuration Register" ] pub cfg : CFG , # [ doc = "0x04 - SMC NFC Control Register" ] pub ctrl : CTRL , # [ doc = "0x08 - SMC NFC Status Register" ] pub sr : SR , # [ doc = "0x0c - SMC NFC Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x10 - SMC NFC Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x14 - SMC NFC Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x18 - SMC NFC Address Cycle Zero Register" ] pub addr : ADDR , # [ doc = "0x1c - SMC Bank Address Register" ] pub bank : BANK , # [ doc = "0x20 - SMC ECC Control Register" ] pub ecc_ctrl : ECC_CTRL , # [ doc = "0x24 - SMC ECC Mode Register" ] pub ecc_md : ECC_MD , # [ doc = "0x28 - SMC ECC Status 1 Register" ] pub ecc_sr1 : ECC_SR1 , # [ doc = "SMC ECC Parity 0 Register" ] pub ecc_pr0 : ECC_PR0_UNION , # [ doc = "SMC ECC parity 1 Register" ] pub ecc_pr1 : ECC_PR1_UNION , # [ doc = "0x34 - SMC ECC status 2 Register" ] pub ecc_sr2 : ECC_SR2 , # [ doc = "SMC ECC parity 2 Register" ] pub ecc_pr2 : ECC_PR2_UNION , # [ doc = "SMC ECC parity 3 Register" ] pub ecc_pr3 : ECC_PR3_UNION , # [ doc = "SMC ECC parity 4 Register" ] pub ecc_pr4 : ECC_PR4_UNION , # [ doc = "SMC ECC parity 5 Register" ] pub ecc_pr5 : ECC_PR5_UNION , # [ doc = "SMC ECC parity 6 Register" ] pub ecc_pr6 : ECC_PR6_UNION , # [ doc = "SMC ECC parity 7 Register" ] pub ecc_pr7 : ECC_PR7_UNION , # [ doc = "0x50 - SMC ECC parity 8 Register" ] pub ecc_pr8 : ECC_PR8 , # [ doc = "0x54 - SMC ECC parity 9 Register" ] pub ecc_pr9 : ECC_PR9 , # [ doc = "0x58 - SMC ECC parity 10 Register" ] pub ecc_pr10 : ECC_PR10 , # [ doc = "0x5c - SMC ECC parity 11 Register" ] pub ecc_pr11 : ECC_PR11 , # [ doc = "0x60 - SMC ECC parity 12 Register" ] pub ecc_pr12 : ECC_PR12 , # [ doc = "0x64 - SMC ECC parity 13 Register" ] pub ecc_pr13 : ECC_PR13 , # [ doc = "0x68 - SMC ECC parity 14 Register" ] pub ecc_pr14 : ECC_PR14 , # [ doc = "0x6c - SMC ECC parity 15 Register" ] pub ecc_pr15 : ECC_PR15 , # [ doc = "0x70 - SMC Setup Register (CS_number = 0)" ] pub setup0 : SETUP0 , # [ doc = "0x74 - SMC Pulse Register (CS_number = 0)" ] pub pulse0 : PULSE0 , # [ doc = "0x78 - SMC Cycle Register (CS_number = 0)" ] pub cycle0 : CYCLE0 , # [ doc = "0x7c - SMC Timings Register (CS_number = 0)" ] pub timings0 : TIMINGS0 , # [ doc = "0x80 - SMC Mode Register (CS_number = 0)" ] pub mode0 : MODE0 , # [ doc = "0x84 - SMC Setup Register (CS_number = 1)" ] pub setup1 : SETUP1 , # [ doc = "0x88 - SMC Pulse Register (CS_number = 1)" ] pub pulse1 : PULSE1 , # [ doc = "0x8c - SMC Cycle Register (CS_number = 1)" ] pub cycle1 : CYCLE1 , # [ doc = "0x90 - SMC Timings Register (CS_number = 1)" ] pub timings1 : TIMINGS1 , # [ doc = "0x94 - SMC Mode Register (CS_number = 1)" ] pub mode1 : MODE1 , # [ doc = "0x98 - SMC Setup Register (CS_number = 2)" ] pub setup2 : SETUP2 , # [ doc = "0x9c - SMC Pulse Register (CS_number = 2)" ] pub pulse2 : PULSE2 , # [ doc = "0xa0 - SMC Cycle Register (CS_number = 2)" ] pub cycle2 : CYCLE2 , # [ doc = "0xa4 - SMC Timings Register (CS_number = 2)" ] pub timings2 : TIMINGS2 , # [ doc = "0xa8 - SMC Mode Register (CS_number = 2)" ] pub mode2 : MODE2 , # [ doc = "0xac - SMC Setup Register (CS_number = 3)" ] pub setup3 : SETUP3 , # [ doc = "0xb0 - SMC Pulse Register (CS_number = 3)" ] pub pulse3 : PULSE3 , # [ doc = "0xb4 - SMC Cycle Register (CS_number = 3)" ] pub cycle3 : CYCLE3 , # [ doc = "0xb8 - SMC Timings Register (CS_number = 3)" ] pub timings3 : TIMINGS3 , # [ doc = "0xbc - SMC Mode Register (CS_number = 3)" ] pub mode3 : MODE3 , # [ doc = "0xc0 - SMC Setup Register (CS_number = 4)" ] pub setup4 : SETUP4 , # [ doc = "0xc4 - SMC Pulse Register (CS_number = 4)" ] pub pulse4 : PULSE4 , # [ doc = "0xc8 - SMC Cycle Register (CS_number = 4)" ] pub cycle4 : CYCLE4 , # [ doc = "0xcc - SMC Timings Register (CS_number = 4)" ] pub timings4 : TIMINGS4 , # [ doc = "0xd0 - SMC Mode Register (CS_number = 4)" ] pub mode4 : MODE4 , # [ doc = "0xd4 - SMC Setup Register (CS_number = 5)" ] pub setup5 : SETUP5 , # [ doc = "0xd8 - SMC Pulse Register (CS_number = 5)" ] pub pulse5 : PULSE5 , # [ doc = "0xdc - SMC Cycle Register (CS_number = 5)" ] pub cycle5 : CYCLE5 , # [ doc = "0xe0 - SMC Timings Register (CS_number = 5)" ] pub timings5 : TIMINGS5 , # [ doc = "0xe4 - SMC Mode Register (CS_number = 5)" ] pub mode5 : MODE5 , # [ doc = "0xe8 - SMC Setup Register (CS_number = 6)" ] pub setup6 : SETUP6 , # [ doc = "0xec - SMC Pulse Register (CS_number = 6)" ] pub pulse6 : PULSE6 , # [ doc = "0xf0 - SMC Cycle Register (CS_number = 6)" ] pub cycle6 : CYCLE6 , # [ doc = "0xf4 - SMC Timings Register (CS_number = 6)" ] pub timings6 : TIMINGS6 , # [ doc = "0xf8 - SMC Mode Register (CS_number = 6)" ] pub mode6 : MODE6 , # [ doc = "0xfc - SMC Setup Register (CS_number = 7)" ] pub setup7 : SETUP7 , # [ doc = "0x100 - SMC Pulse Register (CS_number = 7)" ] pub pulse7 : PULSE7 , # [ doc = "0x104 - SMC Cycle Register (CS_number = 7)" ] pub cycle7 : CYCLE7 , # [ doc = "0x108 - SMC Timings Register (CS_number = 7)" ] pub timings7 : TIMINGS7 , # [ doc = "0x10c - SMC Mode Register (CS_number = 7)" ] pub mode7 : MODE7 , # [ doc = "0x110 - SMC OCMS Register" ] pub ocms : OCMS , # [ doc = "0x114 - SMC OCMS KEY1 Register" ] pub key1 : KEY1 , # [ doc = "0x118 - SMC OCMS KEY2 Register" ] pub key2 : KEY2 , _reserved71 : [ u8 ; 200usize ] , # [ doc = "0x1e4 - Write Protection Control Register" ] pub wpcr : WPCR , # [ doc = "0x1e8 - Write Protection Status Register" ] pub wpsr : WPSR , } # [ doc = "SMC ECC Parity 0 Register" ] # [ repr ( C ) ] pub union ECC_PR0_UNION { # [ doc = "0x2c - SMC ECC Parity 0 Register" ] pub ecc_pr0_w8bit : ECC_PR0_W8BIT , # [ doc = "0x2c - SMC ECC Parity 0 Register" ] pub ecc_pr0_w9bit : ECC_PR0_W9BIT , # [ doc = "0x2c - SMC ECC Parity 0 Register" ] pub ecc_pr0 : ECC_PR0 , } # [ doc = "SMC ECC parity 1 Register" ] # [ repr ( C ) ] pub union ECC_PR1_UNION { # [ doc = "0x30 - SMC ECC parity 1 Register" ] pub ecc_pr1_w8bit : ECC_PR1_W8BIT , # [ doc = "0x30 - SMC ECC parity 1 Register" ] pub ecc_pr1_w9bit : ECC_PR1_W9BIT , # [ doc = "0x30 - SMC ECC parity 1 Register" ] pub ecc_pr1 : ECC_PR1 , } # [ doc = "SMC ECC parity 2 Register" ] # [ repr ( C ) ] pub union ECC_PR2_UNION { # [ doc = "0x38 - SMC ECC parity 2 Register" ] pub ecc_pr2_w8bit : ECC_PR2_W8BIT , # [ doc = "0x38 - SMC ECC parity 2 Register" ] pub ecc_pr2 : ECC_PR2 , } # [ doc = "SMC ECC parity 3 Register" ] # [ repr ( C ) ] pub union ECC_PR3_UNION { # [ doc = "0x3c - SMC ECC parity 3 Register" ] pub ecc_pr3_w8bit : ECC_PR3_W8BIT , # [ doc = "0x3c - SMC ECC parity 3 Register" ] pub ecc_pr3 : ECC_PR3 , } # [ doc = "SMC ECC parity 4 Register" ] # [ repr ( C ) ] pub union ECC_PR4_UNION { # [ doc = "0x40 - SMC ECC parity 4 Register" ] pub ecc_pr4_w8bit : ECC_PR4_W8BIT , # [ doc = "0x40 - SMC ECC parity 4 Register" ] pub ecc_pr4 : ECC_PR4 , } # [ doc = "SMC ECC parity 5 Register" ] # [ repr ( C ) ] pub union ECC_PR5_UNION { # [ doc = "0x44 - SMC ECC parity 5 Register" ] pub ecc_pr5_w8bit : ECC_PR5_W8BIT , # [ doc = "0x44 - SMC ECC parity 5 Register" ] pub ecc_pr5 : ECC_PR5 , } # [ doc = "SMC ECC parity 6 Register" ] # [ repr ( C ) ] pub union ECC_PR6_UNION { # [ doc = "0x48 - SMC ECC parity 6 Register" ] pub ecc_pr6_w8bit : ECC_PR6_W8BIT , # [ doc = "0x48 - SMC ECC parity 6 Register" ] pub ecc_pr6 : ECC_PR6 , } # [ doc = "SMC ECC parity 7 Register" ] # [ repr ( C ) ] pub union ECC_PR7_UNION { # [ doc = "0x4c - SMC ECC parity 7 Register" ] pub ecc_pr7_w8bit : ECC_PR7_W8BIT , # [ doc = "0x4c - SMC ECC parity 7 Register" ] pub ecc_pr7 : ECC_PR7 , } # [ doc = "SMC NFC Configuration Register" ] pub struct CFG { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC NFC Configuration Register" ] pub mod cfg { # [ 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 :: CFG { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `PAGESIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PAGESIZER { # [ doc = "Main area 512 Bytes" ] PS512 , # [ doc = "Main area 1024 Bytes" ] PS1024 , # [ doc = "Main area 2048 Bytes" ] PS2048 , # [ doc = "Main area 4096 Bytes" ] PS4096 } impl PAGESIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PAGESIZER :: PS512 => 0 , PAGESIZER :: PS1024 => 0x01 , PAGESIZER :: PS2048 => 0x02 , PAGESIZER :: PS4096 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PAGESIZER { match value { 0 => PAGESIZER :: PS512 , 1 => PAGESIZER :: PS1024 , 2 => PAGESIZER :: PS2048 , 3 => PAGESIZER :: PS4096 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `PS512`" ] # [ inline ] pub fn is_ps512 ( & self ) -> bool { * self == PAGESIZER :: PS512 } # [ doc = "Checks if the value of the field is `PS1024`" ] # [ inline ] pub fn is_ps1024 ( & self ) -> bool { * self == PAGESIZER :: PS1024 } # [ doc = "Checks if the value of the field is `PS2048`" ] # [ inline ] pub fn is_ps2048 ( & self ) -> bool { * self == PAGESIZER :: PS2048 } # [ doc = "Checks if the value of the field is `PS4096`" ] # [ inline ] pub fn is_ps4096 ( & self ) -> bool { * self == PAGESIZER :: PS4096 } } # [ doc = r" Value of the field" ] pub struct WSPARER { bits : bool , } impl WSPARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RSPARER { bits : bool , } impl RSPARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct EDGECTRLR { bits : bool , } impl EDGECTRLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RBEDGER { bits : bool , } impl RBEDGER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTOCYCR { bits : u8 , } impl DTOCYCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `DTOMUL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DTOMULR { # [ doc = "DTOCYC" ] X1 , # [ doc = "DTOCYC x 16" ] X16 , # [ doc = "DTOCYC x 128" ] X128 , # [ doc = "DTOCYC x 256" ] X256 , # [ doc = "DTOCYC x 1024" ] X1024 , # [ doc = "DTOCYC x 4096" ] X4096 , # [ doc = "DTOCYC x 65536" ] X65536 , # [ doc = "DTOCYC x 1048576" ] X1048576 } impl DTOMULR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DTOMULR :: X1 => 0 , DTOMULR :: X16 => 0x01 , DTOMULR :: X128 => 0x02 , DTOMULR :: X256 => 0x03 , DTOMULR :: X1024 => 0x04 , DTOMULR :: X4096 => 0x05 , DTOMULR :: X65536 => 0x06 , DTOMULR :: X1048576 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DTOMULR { match value { 0 => DTOMULR :: X1 , 1 => DTOMULR :: X16 , 2 => DTOMULR :: X128 , 3 => DTOMULR :: X256 , 4 => DTOMULR :: X1024 , 5 => DTOMULR :: X4096 , 6 => DTOMULR :: X65536 , 7 => DTOMULR :: X1048576 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `X1`" ] # [ inline ] pub fn is_x1 ( & self ) -> bool { * self == DTOMULR :: X1 } # [ doc = "Checks if the value of the field is `X16`" ] # [ inline ] pub fn is_x16 ( & self ) -> bool { * self == DTOMULR :: X16 } # [ doc = "Checks if the value of the field is `X128`" ] # [ inline ] pub fn is_x128 ( & self ) -> bool { * self == DTOMULR :: X128 } # [ doc = "Checks if the value of the field is `X256`" ] # [ inline ] pub fn is_x256 ( & self ) -> bool { * self == DTOMULR :: X256 } # [ doc = "Checks if the value of the field is `X1024`" ] # [ inline ] pub fn is_x1024 ( & self ) -> bool { * self == DTOMULR :: X1024 } # [ doc = "Checks if the value of the field is `X4096`" ] # [ inline ] pub fn is_x4096 ( & self ) -> bool { * self == DTOMULR :: X4096 } # [ doc = "Checks if the value of the field is `X65536`" ] # [ inline ] pub fn is_x65536 ( & self ) -> bool { * self == DTOMULR :: X65536 } # [ doc = "Checks if the value of the field is `X1048576`" ] # [ inline ] pub fn is_x1048576 ( & self ) -> bool { * self == DTOMULR :: X1048576 } } # [ doc = "Values that can be written to the field `PAGESIZE`" ] pub enum PAGESIZEW { # [ doc = "Main area 512 Bytes" ] PS512 , # [ doc = "Main area 1024 Bytes" ] PS1024 , # [ doc = "Main area 2048 Bytes" ] PS2048 , # [ doc = "Main area 4096 Bytes" ] PS4096 } impl PAGESIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PAGESIZEW :: PS512 => 0 , PAGESIZEW :: PS1024 => 1 , PAGESIZEW :: PS2048 => 2 , PAGESIZEW :: PS4096 => 3 } } } # [ doc = r" Proxy" ] pub struct _PAGESIZEW < 'a > { w : & 'a mut W , } impl < 'a > _PAGESIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PAGESIZEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Main area 512 Bytes" ] # [ inline ] pub fn ps512 ( self ) -> & 'a mut W { self . variant ( PAGESIZEW :: PS512 ) } # [ doc = "Main area 1024 Bytes" ] # [ inline ] pub fn ps1024 ( self ) -> & 'a mut W { self . variant ( PAGESIZEW :: PS1024 ) } # [ doc = "Main area 2048 Bytes" ] # [ inline ] pub fn ps2048 ( self ) -> & 'a mut W { self . variant ( PAGESIZEW :: PS2048 ) } # [ doc = "Main area 4096 Bytes" ] # [ inline ] pub fn ps4096 ( self ) -> & 'a mut W { self . variant ( PAGESIZEW :: PS4096 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _WSPAREW < 'a > { w : & 'a mut W , } impl < 'a > _WSPAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSPAREW < 'a > { w : & 'a mut W , } impl < 'a > _RSPAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EDGECTRLW < 'a > { w : & 'a mut W , } impl < 'a > _EDGECTRLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RBEDGEW < 'a > { w : & 'a mut W , } impl < 'a > _RBEDGEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTOCYCW < 'a > { w : & 'a mut W , } impl < 'a > _DTOCYCW < '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 = "Values that can be written to the field `DTOMUL`" ] pub enum DTOMULW { # [ doc = "DTOCYC" ] X1 , # [ doc = "DTOCYC x 16" ] X16 , # [ doc = "DTOCYC x 128" ] X128 , # [ doc = "DTOCYC x 256" ] X256 , # [ doc = "DTOCYC x 1024" ] X1024 , # [ doc = "DTOCYC x 4096" ] X4096 , # [ doc = "DTOCYC x 65536" ] X65536 , # [ doc = "DTOCYC x 1048576" ] X1048576 } impl DTOMULW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DTOMULW :: X1 => 0 , DTOMULW :: X16 => 1 , DTOMULW :: X128 => 2 , DTOMULW :: X256 => 3 , DTOMULW :: X1024 => 4 , DTOMULW :: X4096 => 5 , DTOMULW :: X65536 => 6 , DTOMULW :: X1048576 => 7 } } } # [ doc = r" Proxy" ] pub struct _DTOMULW < 'a > { w : & 'a mut W , } impl < 'a > _DTOMULW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DTOMULW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "DTOCYC" ] # [ inline ] pub fn x1 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X1 ) } # [ doc = "DTOCYC x 16" ] # [ inline ] pub fn x16 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X16 ) } # [ doc = "DTOCYC x 128" ] # [ inline ] pub fn x128 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X128 ) } # [ doc = "DTOCYC x 256" ] # [ inline ] pub fn x256 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X256 ) } # [ doc = "DTOCYC x 1024" ] # [ inline ] pub fn x1024 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X1024 ) } # [ doc = "DTOCYC x 4096" ] # [ inline ] pub fn x4096 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X4096 ) } # [ doc = "DTOCYC x 65536" ] # [ inline ] pub fn x65536 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X65536 ) } # [ doc = "DTOCYC x 1048576" ] # [ inline ] pub fn x1048576 ( self ) -> & 'a mut W { self . variant ( DTOMULW :: X1048576 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; 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 - Page Size of the NAND Flash Device" ] # [ inline ] pub fn pagesize ( & self ) -> PAGESIZER { PAGESIZER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Write Spare Area" ] # [ inline ] pub fn wspare ( & self ) -> WSPARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WSPARER { bits } } # [ doc = "Bit 9 - Read Spare Area" ] # [ inline ] pub fn rspare ( & self ) -> RSPARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RSPARER { bits } } # [ doc = "Bit 12 - Rising/Falling Edge Detection Control" ] # [ inline ] pub fn edgectrl ( & self ) -> EDGECTRLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EDGECTRLR { bits } } # [ doc = "Bit 13 - Ready/Busy Signal Edge Detection" ] # [ inline ] pub fn rbedge ( & self ) -> RBEDGER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RBEDGER { bits } } # [ doc = "Bits 16:19 - Data Timeout Cycle Number" ] # [ inline ] pub fn dtocyc ( & self ) -> DTOCYCR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DTOCYCR { bits } } # [ doc = "Bits 20:22 - Data Timeout Multiplier" ] # [ inline ] pub fn dtomul ( & self ) -> DTOMULR { DTOMULR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Page Size of the NAND Flash Device" ] # [ inline ] pub fn pagesize ( & mut self ) -> _PAGESIZEW { _PAGESIZEW { w : self } } # [ doc = "Bit 8 - Write Spare Area" ] # [ inline ] pub fn wspare ( & mut self ) -> _WSPAREW { _WSPAREW { w : self } } # [ doc = "Bit 9 - Read Spare Area" ] # [ inline ] pub fn rspare ( & mut self ) -> _RSPAREW { _RSPAREW { w : self } } # [ doc = "Bit 12 - Rising/Falling Edge Detection Control" ] # [ inline ] pub fn edgectrl ( & mut self ) -> _EDGECTRLW { _EDGECTRLW { w : self } } # [ doc = "Bit 13 - Ready/Busy Signal Edge Detection" ] # [ inline ] pub fn rbedge ( & mut self ) -> _RBEDGEW { _RBEDGEW { w : self } } # [ doc = "Bits 16:19 - Data Timeout Cycle Number" ] # [ inline ] pub fn dtocyc ( & mut self ) -> _DTOCYCW { _DTOCYCW { w : self } } # [ doc = "Bits 20:22 - Data Timeout Multiplier" ] # [ inline ] pub fn dtomul ( & mut self ) -> _DTOMULW { _DTOMULW { w : self } } } } # [ doc = "SMC NFC Control Register" ] pub struct CTRL { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC NFC Control Register" ] pub mod ctrl { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CTRL { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _NFCENW < 'a > { w : & 'a mut W , } impl < 'a > _NFCENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NFCDISW < 'a > { w : & 'a mut W , } impl < 'a > _NFCDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - NAND Flash Controller Enable" ] # [ inline ] pub fn nfcen ( & mut self ) -> _NFCENW { _NFCENW { w : self } } # [ doc = "Bit 1 - NAND Flash Controller Disable" ] # [ inline ] pub fn nfcdis ( & mut self ) -> _NFCDISW { _NFCDISW { w : self } } } } # [ doc = "SMC NFC Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC NFC 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 SMCSTSR { bits : bool , } impl SMCSTSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RB_RISER { bits : bool , } impl RB_RISER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RB_FALLR { bits : bool , } impl RB_FALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NFCBUSYR { bits : bool , } impl NFCBUSYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NFCWRR { bits : bool , } impl NFCWRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NFCSIDR { bits : u8 , } impl NFCSIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct XFRDONER { bits : bool , } impl XFRDONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMDDONER { bits : bool , } impl CMDDONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTOER { bits : bool , } impl DTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDEFR { bits : bool , } impl UNDEFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct AWBR { bits : bool , } impl AWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NFCASER { bits : bool , } impl NFCASER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RB_EDGE0R { bits : bool , } impl RB_EDGE0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - NAND Flash Controller status (this field cannot be reset)" ] # [ inline ] pub fn smcsts ( & self ) -> SMCSTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SMCSTSR { bits } } # [ doc = "Bit 4 - Selected Ready Busy Rising Edge Detected" ] # [ inline ] pub fn rb_rise ( & self ) -> RB_RISER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RB_RISER { bits } } # [ doc = "Bit 5 - Selected Ready Busy Falling Edge Detected" ] # [ inline ] pub fn rb_fall ( & self ) -> RB_FALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RB_FALLR { bits } } # [ doc = "Bit 8 - NFC Busy (this field cannot be reset)" ] # [ inline ] pub fn nfcbusy ( & self ) -> NFCBUSYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFCBUSYR { bits } } # [ doc = "Bit 11 - NFC Write/Read Operation (this field cannot be reset)" ] # [ inline ] pub fn nfcwr ( & self ) -> NFCWRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFCWRR { bits } } # [ doc = "Bits 12:14 - NFC Chip Select ID (this field cannot be reset)" ] # [ inline ] pub fn nfcsid ( & self ) -> NFCSIDR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NFCSIDR { bits } } # [ doc = "Bit 16 - NFC Data Transfer Terminated" ] # [ inline ] pub fn xfrdone ( & self ) -> XFRDONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; XFRDONER { bits } } # [ doc = "Bit 17 - Command Done" ] # [ inline ] pub fn cmddone ( & self ) -> CMDDONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMDDONER { bits } } # [ doc = "Bit 20 - Data Timeout Error" ] # [ inline ] pub fn dtoe ( & self ) -> DTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTOER { bits } } # [ doc = "Bit 21 - Undefined Area Error" ] # [ inline ] pub fn undef ( & self ) -> UNDEFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDEFR { bits } } # [ doc = "Bit 22 - Accessing While Busy" ] # [ inline ] pub fn awb ( & self ) -> AWBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AWBR { bits } } # [ doc = "Bit 23 - NFC Access Size Error" ] # [ inline ] pub fn nfcase ( & self ) -> NFCASER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFCASER { bits } } # [ doc = "Bit 24 - Ready/Busy Line 0 Edge Detected" ] # [ inline ] pub fn rb_edge0 ( & self ) -> RB_EDGE0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RB_EDGE0R { bits } } } } # [ doc = "SMC NFC Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC NFC Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RB_RISEW < 'a > { w : & 'a mut W , } impl < 'a > _RB_RISEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RB_FALLW < 'a > { w : & 'a mut W , } impl < 'a > _RB_FALLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _XFRDONEW < 'a > { w : & 'a mut W , } impl < 'a > _XFRDONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMDDONEW < 'a > { w : & 'a mut W , } impl < 'a > _CMDDONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTOEW < 'a > { w : & 'a mut W , } impl < 'a > _DTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDEFW < 'a > { w : & 'a mut W , } impl < 'a > _UNDEFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AWBW < 'a > { w : & 'a mut W , } impl < 'a > _AWBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NFCASEW < 'a > { w : & 'a mut W , } impl < 'a > _NFCASEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RB_EDGE0W < 'a > { w : & 'a mut W , } impl < 'a > _RB_EDGE0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 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 - Ready Busy Rising Edge Detection Interrupt Enable" ] # [ inline ] pub fn rb_rise ( & mut self ) -> _RB_RISEW { _RB_RISEW { w : self } } # [ doc = "Bit 5 - Ready Busy Falling Edge Detection Interrupt Enable" ] # [ inline ] pub fn rb_fall ( & mut self ) -> _RB_FALLW { _RB_FALLW { w : self } } # [ doc = "Bit 16 - Transfer Done Interrupt Enable" ] # [ inline ] pub fn xfrdone ( & mut self ) -> _XFRDONEW { _XFRDONEW { w : self } } # [ doc = "Bit 17 - Command Done Interrupt Enable" ] # [ inline ] pub fn cmddone ( & mut self ) -> _CMDDONEW { _CMDDONEW { w : self } } # [ doc = "Bit 20 - Data Timeout Error Interrupt Enable" ] # [ inline ] pub fn dtoe ( & mut self ) -> _DTOEW { _DTOEW { w : self } } # [ doc = "Bit 21 - Undefined Area Access Interrupt Enable" ] # [ inline ] pub fn undef ( & mut self ) -> _UNDEFW { _UNDEFW { w : self } } # [ doc = "Bit 22 - Accessing While Busy Interrupt Enable" ] # [ inline ] pub fn awb ( & mut self ) -> _AWBW { _AWBW { w : self } } # [ doc = "Bit 23 - NFC Access Size Error Interrupt Enable" ] # [ inline ] pub fn nfcase ( & mut self ) -> _NFCASEW { _NFCASEW { w : self } } # [ doc = "Bit 24 - Ready/Busy Line 0 Interrupt Enable" ] # [ inline ] pub fn rb_edge0 ( & mut self ) -> _RB_EDGE0W { _RB_EDGE0W { w : self } } } } # [ doc = "SMC NFC Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC NFC Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RB_RISEW < 'a > { w : & 'a mut W , } impl < 'a > _RB_RISEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RB_FALLW < 'a > { w : & 'a mut W , } impl < 'a > _RB_FALLW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _XFRDONEW < 'a > { w : & 'a mut W , } impl < 'a > _XFRDONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CMDDONEW < 'a > { w : & 'a mut W , } impl < 'a > _CMDDONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DTOEW < 'a > { w : & 'a mut W , } impl < 'a > _DTOEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UNDEFW < 'a > { w : & 'a mut W , } impl < 'a > _UNDEFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _AWBW < 'a > { w : & 'a mut W , } impl < 'a > _AWBW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _NFCASEW < 'a > { w : & 'a mut W , } impl < 'a > _NFCASEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RB_EDGE0W < 'a > { w : & 'a mut W , } impl < 'a > _RB_EDGE0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 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 - Ready Busy Rising Edge Detection Interrupt Disable" ] # [ inline ] pub fn rb_rise ( & mut self ) -> _RB_RISEW { _RB_RISEW { w : self } } # [ doc = "Bit 5 - Ready Busy Falling Edge Detection Interrupt Disable" ] # [ inline ] pub fn rb_fall ( & mut self ) -> _RB_FALLW { _RB_FALLW { w : self } } # [ doc = "Bit 16 - Transfer Done Interrupt Disable" ] # [ inline ] pub fn xfrdone ( & mut self ) -> _XFRDONEW { _XFRDONEW { w : self } } # [ doc = "Bit 17 - Command Done Interrupt Disable" ] # [ inline ] pub fn cmddone ( & mut self ) -> _CMDDONEW { _CMDDONEW { w : self } } # [ doc = "Bit 20 - Data Timeout Error Interrupt Disable" ] # [ inline ] pub fn dtoe ( & mut self ) -> _DTOEW { _DTOEW { w : self } } # [ doc = "Bit 21 - Undefined Area Access Interrupt Disable" ] # [ inline ] pub fn undef ( & mut self ) -> _UNDEFW { _UNDEFW { w : self } } # [ doc = "Bit 22 - Accessing While Busy Interrupt Disable" ] # [ inline ] pub fn awb ( & mut self ) -> _AWBW { _AWBW { w : self } } # [ doc = "Bit 23 - NFC Access Size Error Interrupt Disable" ] # [ inline ] pub fn nfcase ( & mut self ) -> _NFCASEW { _NFCASEW { w : self } } # [ doc = "Bit 24 - Ready/Busy Line 0 Interrupt Disable" ] # [ inline ] pub fn rb_edge0 ( & mut self ) -> _RB_EDGE0W { _RB_EDGE0W { w : self } } } } # [ doc = "SMC NFC Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC NFC Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 RB_RISER { bits : bool , } impl RB_RISER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RB_FALLR { bits : bool , } impl RB_FALLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct XFRDONER { bits : bool , } impl XFRDONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CMDDONER { bits : bool , } impl CMDDONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DTOER { bits : bool , } impl DTOER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UNDEFR { bits : bool , } impl UNDEFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct AWBR { bits : bool , } impl AWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NFCASER { bits : bool , } impl NFCASER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RB_EDGE0R { bits : bool , } impl RB_EDGE0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 4 - Ready Busy Rising Edge Detection Interrupt Mask" ] # [ inline ] pub fn rb_rise ( & self ) -> RB_RISER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RB_RISER { bits } } # [ doc = "Bit 5 - Ready Busy Falling Edge Detection Interrupt Mask" ] # [ inline ] pub fn rb_fall ( & self ) -> RB_FALLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RB_FALLR { bits } } # [ doc = "Bit 16 - Transfer Done Interrupt Mask" ] # [ inline ] pub fn xfrdone ( & self ) -> XFRDONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; XFRDONER { bits } } # [ doc = "Bit 17 - Command Done Interrupt Mask" ] # [ inline ] pub fn cmddone ( & self ) -> CMDDONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMDDONER { bits } } # [ doc = "Bit 20 - Data Timeout Error Interrupt Mask" ] # [ inline ] pub fn dtoe ( & self ) -> DTOER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DTOER { bits } } # [ doc = "Bit 21 - Undefined Area Access Interrupt Mask5" ] # [ inline ] pub fn undef ( & self ) -> UNDEFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UNDEFR { bits } } # [ doc = "Bit 22 - Accessing While Busy Interrupt Mask" ] # [ inline ] pub fn awb ( & self ) -> AWBR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AWBR { bits } } # [ doc = "Bit 23 - NFC Access Size Error Interrupt Mask" ] # [ inline ] pub fn nfcase ( & self ) -> NFCASER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFCASER { bits } } # [ doc = "Bit 24 - Ready/Busy Line 0 Interrupt Mask" ] # [ inline ] pub fn rb_edge0 ( & self ) -> RB_EDGE0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RB_EDGE0R { bits } } } } # [ doc = "SMC NFC Address Cycle Zero Register" ] pub struct ADDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC NFC Address Cycle Zero Register" ] pub mod addr { # [ 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 :: ADDR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ADDR_CYCLE0R { bits : u8 , } impl ADDR_CYCLE0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _ADDR_CYCLE0W < 'a > { w : & 'a mut W , } impl < 'a > _ADDR_CYCLE0W < '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 - NAND Flash Array Address cycle 0" ] # [ inline ] pub fn addr_cycle0 ( & self ) -> ADDR_CYCLE0R { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; ADDR_CYCLE0R { 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 - NAND Flash Array Address cycle 0" ] # [ inline ] pub fn addr_cycle0 ( & mut self ) -> _ADDR_CYCLE0W { _ADDR_CYCLE0W { w : self } } } } # [ doc = "SMC Bank Address Register" ] pub struct BANK { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Bank Address Register" ] pub mod bank { # [ 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 :: BANK { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 BANKR { bits : u8 , } impl BANKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _BANKW < 'a > { w : & 'a mut W , } impl < 'a > _BANKW < '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 - Bank Identifier" ] # [ inline ] pub fn bank ( & self ) -> BANKR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BANKR { 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 - Bank Identifier" ] # [ inline ] pub fn bank ( & mut self ) -> _BANKW { _BANKW { w : self } } } } # [ doc = "SMC ECC Control Register" ] pub struct ECC_CTRL { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC Control Register" ] pub mod ecc_ctrl { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ECC_CTRL { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RSTW < 'a > { w : & 'a mut W , } impl < 'a > _RSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _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 = 1 ; 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 - Reset ECC" ] # [ inline ] pub fn rst ( & mut self ) -> _RSTW { _RSTW { w : self } } # [ doc = "Bit 1 - Software Reset" ] # [ inline ] pub fn swrst ( & mut self ) -> _SWRSTW { _SWRSTW { w : self } } } } # [ doc = "SMC ECC Mode Register" ] pub struct ECC_MD { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC Mode Register" ] pub mod ecc_md { # [ 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 :: ECC_MD { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `ECC_PAGESIZE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ECC_PAGESIZER { # [ doc = "Main area 512 Words" ] PS512 , # [ doc = "Main area 1024 Words" ] PS1024 , # [ doc = "Main area 2048 Words" ] PS2048 , # [ doc = "Main area 4096 Words" ] PS4096 } impl ECC_PAGESIZER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ECC_PAGESIZER :: PS512 => 0 , ECC_PAGESIZER :: PS1024 => 0x01 , ECC_PAGESIZER :: PS2048 => 0x02 , ECC_PAGESIZER :: PS4096 => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ECC_PAGESIZER { match value { 0 => ECC_PAGESIZER :: PS512 , 1 => ECC_PAGESIZER :: PS1024 , 2 => ECC_PAGESIZER :: PS2048 , 3 => ECC_PAGESIZER :: PS4096 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `PS512`" ] # [ inline ] pub fn is_ps512 ( & self ) -> bool { * self == ECC_PAGESIZER :: PS512 } # [ doc = "Checks if the value of the field is `PS1024`" ] # [ inline ] pub fn is_ps1024 ( & self ) -> bool { * self == ECC_PAGESIZER :: PS1024 } # [ doc = "Checks if the value of the field is `PS2048`" ] # [ inline ] pub fn is_ps2048 ( & self ) -> bool { * self == ECC_PAGESIZER :: PS2048 } # [ doc = "Checks if the value of the field is `PS4096`" ] # [ inline ] pub fn is_ps4096 ( & self ) -> bool { * self == ECC_PAGESIZER :: PS4096 } } # [ doc = "Possible values of the field `TYPCORREC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TYPCORRECR { # [ doc = "1 bit correction for a page of 512/1024/2048/4096 Bytes  (for 8 or 16-bit NAND Flash)" ] CPAGE , # [ doc = "1 bit correction for 256 Bytes of data for a page of 512/2048/4096 bytes (for 8-bit NAND Flash only)" ] C256B , # [ doc = "1 bit correction for 512 Bytes of data for a page of 512/2048/4096 bytes (for 8-bit NAND Flash only)" ] C512B , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl TYPCORRECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TYPCORRECR :: CPAGE => 0 , TYPCORRECR :: C256B => 0x01 , TYPCORRECR :: C512B => 0x02 , TYPCORRECR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TYPCORRECR { match value { 0 => TYPCORRECR :: CPAGE , 1 => TYPCORRECR :: C256B , 2 => TYPCORRECR :: C512B , i => TYPCORRECR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CPAGE`" ] # [ inline ] pub fn is_cpage ( & self ) -> bool { * self == TYPCORRECR :: CPAGE } # [ doc = "Checks if the value of the field is `C256B`" ] # [ inline ] pub fn is_c256b ( & self ) -> bool { * self == TYPCORRECR :: C256B } # [ doc = "Checks if the value of the field is `C512B`" ] # [ inline ] pub fn is_c512b ( & self ) -> bool { * self == TYPCORRECR :: C512B } } # [ doc = "Values that can be written to the field `ECC_PAGESIZE`" ] pub enum ECC_PAGESIZEW { # [ doc = "Main area 512 Words" ] PS512 , # [ doc = "Main area 1024 Words" ] PS1024 , # [ doc = "Main area 2048 Words" ] PS2048 , # [ doc = "Main area 4096 Words" ] PS4096 } impl ECC_PAGESIZEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { ECC_PAGESIZEW :: PS512 => 0 , ECC_PAGESIZEW :: PS1024 => 1 , ECC_PAGESIZEW :: PS2048 => 2 , ECC_PAGESIZEW :: PS4096 => 3 } } } # [ doc = r" Proxy" ] pub struct _ECC_PAGESIZEW < 'a > { w : & 'a mut W , } impl < 'a > _ECC_PAGESIZEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : ECC_PAGESIZEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Main area 512 Words" ] # [ inline ] pub fn ps512 ( self ) -> & 'a mut W { self . variant ( ECC_PAGESIZEW :: PS512 ) } # [ doc = "Main area 1024 Words" ] # [ inline ] pub fn ps1024 ( self ) -> & 'a mut W { self . variant ( ECC_PAGESIZEW :: PS1024 ) } # [ doc = "Main area 2048 Words" ] # [ inline ] pub fn ps2048 ( self ) -> & 'a mut W { self . variant ( ECC_PAGESIZEW :: PS2048 ) } # [ doc = "Main area 4096 Words" ] # [ inline ] pub fn ps4096 ( self ) -> & 'a mut W { self . variant ( ECC_PAGESIZEW :: PS4096 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `TYPCORREC`" ] pub enum TYPCORRECW { # [ doc = "1 bit correction for a page of 512/1024/2048/4096 Bytes  (for 8 or 16-bit NAND Flash)" ] CPAGE , # [ doc = "1 bit correction for 256 Bytes of data for a page of 512/2048/4096 bytes (for 8-bit NAND Flash only)" ] C256B , # [ doc = "1 bit correction for 512 Bytes of data for a page of 512/2048/4096 bytes (for 8-bit NAND Flash only)" ] C512B } impl TYPCORRECW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TYPCORRECW :: CPAGE => 0 , TYPCORRECW :: C256B => 1 , TYPCORRECW :: C512B => 2 } } } # [ doc = r" Proxy" ] pub struct _TYPCORRECW < 'a > { w : & 'a mut W , } impl < 'a > _TYPCORRECW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TYPCORRECW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "1 bit correction for a page of 512/1024/2048/4096 Bytes (for 8 or 16-bit NAND Flash)" ] # [ inline ] pub fn cpage ( self ) -> & 'a mut W { self . variant ( TYPCORRECW :: CPAGE ) } # [ doc = "1 bit correction for 256 Bytes of data for a page of 512/2048/4096 bytes (for 8-bit NAND Flash only)" ] # [ inline ] pub fn c256b ( self ) -> & 'a mut W { self . variant ( TYPCORRECW :: C256B ) } # [ doc = "1 bit correction for 512 Bytes of data for a page of 512/2048/4096 bytes (for 8-bit NAND Flash only)" ] # [ inline ] pub fn c512b ( self ) -> & 'a mut W { self . variant ( TYPCORRECW :: C512B ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - ECC Page Size" ] # [ inline ] pub fn ecc_pagesize ( & self ) -> ECC_PAGESIZER { ECC_PAGESIZER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:5 - Type of Correction" ] # [ inline ] pub fn typcorrec ( & self ) -> TYPCORRECR { TYPCORRECR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - ECC Page Size" ] # [ inline ] pub fn ecc_pagesize ( & mut self ) -> _ECC_PAGESIZEW { _ECC_PAGESIZEW { w : self } } # [ doc = "Bits 4:5 - Type of Correction" ] # [ inline ] pub fn typcorrec ( & mut self ) -> _TYPCORRECW { _TYPCORRECW { w : self } } } } # [ doc = "SMC ECC Status 1 Register" ] pub struct ECC_SR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC Status 1 Register" ] pub mod ecc_sr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_SR1 { # [ 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 RECERR0R { bits : bool , } impl RECERR0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR0R { bits : bool , } impl ECCERR0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR0R { bits : bool , } impl MULERR0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR1R { bits : bool , } impl RECERR1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR1R { bits : bool , } impl ECCERR1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR1R { bits : bool , } impl MULERR1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR2R { bits : bool , } impl RECERR2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR2R { bits : bool , } impl ECCERR2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR2R { bits : bool , } impl MULERR2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR3R { bits : bool , } impl RECERR3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR3R { bits : bool , } impl ECCERR3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR3R { bits : bool , } impl MULERR3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR4R { bits : bool , } impl RECERR4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR4R { bits : bool , } impl ECCERR4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR4R { bits : bool , } impl MULERR4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR5R { bits : bool , } impl RECERR5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR5R { bits : bool , } impl ECCERR5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR5R { bits : bool , } impl MULERR5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR6R { bits : bool , } impl RECERR6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR6R { bits : bool , } impl ECCERR6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR6R { bits : bool , } impl MULERR6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR7R { bits : bool , } impl RECERR7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR7R { bits : bool , } impl ECCERR7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR7R { bits : bool , } impl MULERR7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Recoverable Error" ] # [ inline ] pub fn recerr0 ( & self ) -> RECERR0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR0R { bits } } # [ doc = "Bit 1 - ECC Error" ] # [ inline ] pub fn eccerr0 ( & self ) -> ECCERR0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR0R { bits } } # [ doc = "Bit 2 - Multiple Error" ] # [ inline ] pub fn mulerr0 ( & self ) -> MULERR0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR0R { bits } } # [ doc = "Bit 4 - Recoverable Error in the page between the 256th and the 511th bytes or the 512nd and the 1023rd bytes" ] # [ inline ] pub fn recerr1 ( & self ) -> RECERR1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR1R { bits } } # [ doc = "Bit 5 - ECC Error in the page between the 256th and the 511th bytes or between the 512nd and the 1023rd bytes" ] # [ inline ] pub fn eccerr1 ( & self ) -> ECCERR1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR1R { bits } } # [ doc = "Bit 6 - Multiple Error in the page between the 256th and the 511th bytes or between the 512nd and the 1023rd bytes" ] # [ inline ] pub fn mulerr1 ( & self ) -> MULERR1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR1R { bits } } # [ doc = "Bit 8 - Recoverable Error in the page between the 512nd and the 767th bytes or between the 1024th and the 1535th bytes" ] # [ inline ] pub fn recerr2 ( & self ) -> RECERR2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR2R { bits } } # [ doc = "Bit 9 - ECC Error in the page between the 512nd and the 767th bytes or between the 1024th and the 1535th bytes" ] # [ inline ] pub fn eccerr2 ( & self ) -> ECCERR2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR2R { bits } } # [ doc = "Bit 10 - Multiple Error in the page between the 512nd and the 767th bytes or between the 1024th and the 1535th bytes" ] # [ inline ] pub fn mulerr2 ( & self ) -> MULERR2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR2R { bits } } # [ doc = "Bit 12 - Recoverable Error in the page between the 768th and the 1023rd bytes or between the 1536th and the 2047th bytes" ] # [ inline ] pub fn recerr3 ( & self ) -> RECERR3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR3R { bits } } # [ doc = "Bit 13 - ECC Error in the page between the 768th and the 1023rd bytes or between the 1536th and the 2047th bytes" ] # [ inline ] pub fn eccerr3 ( & self ) -> ECCERR3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR3R { bits } } # [ doc = "Bit 14 - Multiple Error in the page between the 768th and the 1023rd bytes or between the 1536th and the 2047th bytes" ] # [ inline ] pub fn mulerr3 ( & self ) -> MULERR3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR3R { bits } } # [ doc = "Bit 16 - Recoverable Error in the page between the 1024th and the 1279th bytes or between the 2048th and the 2559th bytes" ] # [ inline ] pub fn recerr4 ( & self ) -> RECERR4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR4R { bits } } # [ doc = "Bit 17 - ECC Error in the page between the 1024th and the 1279th bytes or between the 2048th and the 2559th bytes" ] # [ inline ] pub fn eccerr4 ( & self ) -> ECCERR4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR4R { bits } } # [ doc = "Bit 18 - Multiple Error in the page between the 1024th and the 1279th bytes or between the 2048th and the 2559th bytes" ] # [ inline ] pub fn mulerr4 ( & self ) -> MULERR4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR4R { bits } } # [ doc = "Bit 20 - Recoverable Error in the page between the 1280th and the 1535th bytes or between the 2560th and the 3071st bytes" ] # [ inline ] pub fn recerr5 ( & self ) -> RECERR5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR5R { bits } } # [ doc = "Bit 21 - ECC Error in the page between the 1280th and the 1535th bytes or between the 2560th and the 3071st bytes" ] # [ inline ] pub fn eccerr5 ( & self ) -> ECCERR5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR5R { bits } } # [ doc = "Bit 22 - Multiple Error in the page between the 1280th and the 1535th bytes or between the 2560th and the 3071st bytes" ] # [ inline ] pub fn mulerr5 ( & self ) -> MULERR5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR5R { bits } } # [ doc = "Bit 24 - Recoverable Error in the page between the 1536th and the 1791st bytes or between the 3072nd and the 3583rd bytes" ] # [ inline ] pub fn recerr6 ( & self ) -> RECERR6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR6R { bits } } # [ doc = "Bit 25 - ECC Error in the page between the 1536th and the 1791st bytes or between the 3072nd and the 3583rd bytes" ] # [ inline ] pub fn eccerr6 ( & self ) -> ECCERR6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR6R { bits } } # [ doc = "Bit 26 - Multiple Error in the page between the 1536th and the 1791st bytes or between the 3072nd and the 3583rd bytes" ] # [ inline ] pub fn mulerr6 ( & self ) -> MULERR6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR6R { bits } } # [ doc = "Bit 28 - Recoverable Error in the page between the 1792nd and the 2047th bytes or between the 3584th and the 4095th bytes" ] # [ inline ] pub fn recerr7 ( & self ) -> RECERR7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR7R { bits } } # [ doc = "Bit 29 - ECC Error in the page between the 1792nd and the 2047th bytes or between the 3584th and the 4095th bytes" ] # [ inline ] pub fn eccerr7 ( & self ) -> ECCERR7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR7R { bits } } # [ doc = "Bit 30 - Multiple Error in the page between the 1792nd and the 2047th bytes or between the 3584th and the 4095th bytes" ] # [ inline ] pub fn mulerr7 ( & self ) -> MULERR7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR7R { bits } } } } # [ doc = "SMC ECC Parity 0 Register" ] pub struct ECC_PR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC Parity 0 Register" ] pub mod ecc_pr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR0 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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:3 - Bit Address" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 4:15 - Word Address" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } } } # [ doc = "SMC ECC Parity 0 Register" ] pub struct ECC_PR0_W9BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC Parity 0 Register" ] pub mod ecc_pr0_w9bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR0_W9BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC Parity 0 Register" ] pub struct ECC_PR0_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC Parity 0 Register" ] pub mod ecc_pr0_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR0_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 1 Register" ] pub struct ECC_PR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 1 Register" ] pub mod ecc_pr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR1 { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 1 Register" ] pub struct ECC_PR1_W9BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 1 Register" ] pub mod ecc_pr1_w9bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR1_W9BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 1 Register" ] pub struct ECC_PR1_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 1 Register" ] pub mod ecc_pr1_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR1_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC status 2 Register" ] pub struct ECC_SR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC status 2 Register" ] pub mod ecc_sr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_SR2 { # [ 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 RECERR8R { bits : bool , } impl RECERR8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR8R { bits : bool , } impl ECCERR8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR8R { bits : bool , } impl MULERR8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR9R { bits : bool , } impl RECERR9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR9R { bits : bool , } impl ECCERR9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR9R { bits : bool , } impl MULERR9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR10R { bits : bool , } impl RECERR10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR10R { bits : bool , } impl ECCERR10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR10R { bits : bool , } impl MULERR10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR11R { bits : bool , } impl RECERR11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR11R { bits : bool , } impl ECCERR11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR11R { bits : bool , } impl MULERR11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR12R { bits : bool , } impl RECERR12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR12R { bits : bool , } impl ECCERR12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR12R { bits : bool , } impl MULERR12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR13R { bits : bool , } impl RECERR13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR13R { bits : bool , } impl ECCERR13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR13R { bits : bool , } impl MULERR13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR14R { bits : bool , } impl RECERR14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR14R { bits : bool , } impl ECCERR14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR14R { bits : bool , } impl MULERR14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RECERR15R { bits : bool , } impl RECERR15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ECCERR15R { bits : bool , } impl ECCERR15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MULERR15R { bits : bool , } impl MULERR15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Recoverable Error in the page between the 2048th and the 2303rd bytes" ] # [ inline ] pub fn recerr8 ( & self ) -> RECERR8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR8R { bits } } # [ doc = "Bit 1 - ECC Error in the page between the 2048th and the 2303rd bytes" ] # [ inline ] pub fn eccerr8 ( & self ) -> ECCERR8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR8R { bits } } # [ doc = "Bit 2 - Multiple Error in the page between the 2048th and the 2303rd bytes" ] # [ inline ] pub fn mulerr8 ( & self ) -> MULERR8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR8R { bits } } # [ doc = "Bit 4 - Recoverable Error in the page between the 2304th and the 2559th bytes" ] # [ inline ] pub fn recerr9 ( & self ) -> RECERR9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR9R { bits } } # [ doc = "Bit 5 - ECC Error in the page between the 2304th and the 2559th bytes" ] # [ inline ] pub fn eccerr9 ( & self ) -> ECCERR9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR9R { bits } } # [ doc = "Bit 6 - Multiple Error in the page between the 2304th and the 2559th bytes" ] # [ inline ] pub fn mulerr9 ( & self ) -> MULERR9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR9R { bits } } # [ doc = "Bit 8 - Recoverable Error in the page between the 2560th and the 2815th bytes" ] # [ inline ] pub fn recerr10 ( & self ) -> RECERR10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR10R { bits } } # [ doc = "Bit 9 - ECC Error in the page between the 2560th and the 2815th bytes" ] # [ inline ] pub fn eccerr10 ( & self ) -> ECCERR10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR10R { bits } } # [ doc = "Bit 10 - Multiple Error in the page between the 2560th and the 2815th bytes" ] # [ inline ] pub fn mulerr10 ( & self ) -> MULERR10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR10R { bits } } # [ doc = "Bit 12 - Recoverable Error in the page between the 2816th and the 3071st bytes" ] # [ inline ] pub fn recerr11 ( & self ) -> RECERR11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR11R { bits } } # [ doc = "Bit 13 - ECC Error in the page between the 2816th and the 3071st bytes" ] # [ inline ] pub fn eccerr11 ( & self ) -> ECCERR11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR11R { bits } } # [ doc = "Bit 14 - Multiple Error in the page between the 2816th and the 3071st bytes" ] # [ inline ] pub fn mulerr11 ( & self ) -> MULERR11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR11R { bits } } # [ doc = "Bit 16 - Recoverable Error in the page between the 3072nd and the 3327th bytes" ] # [ inline ] pub fn recerr12 ( & self ) -> RECERR12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR12R { bits } } # [ doc = "Bit 17 - ECC Error in the page between the 3072nd and the 3327th bytes" ] # [ inline ] pub fn eccerr12 ( & self ) -> ECCERR12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR12R { bits } } # [ doc = "Bit 18 - Multiple Error in the page between the 3072nd and the 3327th bytes" ] # [ inline ] pub fn mulerr12 ( & self ) -> MULERR12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR12R { bits } } # [ doc = "Bit 20 - Recoverable Error in the page between the 3328th and the 3583rd bytes" ] # [ inline ] pub fn recerr13 ( & self ) -> RECERR13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR13R { bits } } # [ doc = "Bit 21 - ECC Error in the page between the 3328th and the 3583rd bytes" ] # [ inline ] pub fn eccerr13 ( & self ) -> ECCERR13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR13R { bits } } # [ doc = "Bit 22 - Multiple Error in the page between the 3328th and the 3583rd bytes" ] # [ inline ] pub fn mulerr13 ( & self ) -> MULERR13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR13R { bits } } # [ doc = "Bit 24 - Recoverable Error in the page between the 3584th and the 3839th bytes" ] # [ inline ] pub fn recerr14 ( & self ) -> RECERR14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR14R { bits } } # [ doc = "Bit 25 - ECC Error in the page between the 3584th and the 3839th bytes" ] # [ inline ] pub fn eccerr14 ( & self ) -> ECCERR14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR14R { bits } } # [ doc = "Bit 26 - Multiple Error in the page between the 3584th and the 3839th bytes" ] # [ inline ] pub fn mulerr14 ( & self ) -> MULERR14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR14R { bits } } # [ doc = "Bit 28 - Recoverable Error in the page between the 3840th and the 4095th bytes" ] # [ inline ] pub fn recerr15 ( & self ) -> RECERR15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RECERR15R { bits } } # [ doc = "Bit 29 - ECC Error in the page between the 3840th and the 4095th bytes" ] # [ inline ] pub fn eccerr15 ( & self ) -> ECCERR15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ECCERR15R { bits } } # [ doc = "Bit 30 - Multiple Error in the page between the 3840th and the 4095th bytes" ] # [ inline ] pub fn mulerr15 ( & self ) -> MULERR15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MULERR15R { bits } } } } # [ doc = "SMC ECC parity 2 Register" ] pub struct ECC_PR2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 2 Register" ] pub mod ecc_pr2 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR2 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 2 Register" ] pub struct ECC_PR2_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 2 Register" ] pub mod ecc_pr2_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR2_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 3 Register" ] pub struct ECC_PR3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 3 Register" ] pub mod ecc_pr3 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR3 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 3 Register" ] pub struct ECC_PR3_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 3 Register" ] pub mod ecc_pr3_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR3_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 4 Register" ] pub struct ECC_PR4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 4 Register" ] pub mod ecc_pr4 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR4 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 4 Register" ] pub struct ECC_PR4_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 4 Register" ] pub mod ecc_pr4_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR4_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 5 Register" ] pub struct ECC_PR5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 5 Register" ] pub mod ecc_pr5 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR5 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 5 Register" ] pub struct ECC_PR5_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 5 Register" ] pub mod ecc_pr5_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR5_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 6 Register" ] pub struct ECC_PR6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 6 Register" ] pub mod ecc_pr6 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR6 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 6 Register" ] pub struct ECC_PR6_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 6 Register" ] pub mod ecc_pr6_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR6_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 7 Register" ] pub struct ECC_PR7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 7 Register" ] pub mod ecc_pr7 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR7 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u16 , } impl WORDADDRR { # [ 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 NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:11 - Corrupted Word Address in the Page between (i x 512) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WORDADDRR { bits } } # [ doc = "Bits 12:23 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 7 Register" ] pub struct ECC_PR7_W8BIT { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 7 Register" ] pub mod ecc_pr7_w8bit { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR7_W8BIT { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 8 Register" ] pub struct ECC_PR8 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 8 Register" ] pub mod ecc_pr8 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR8 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 9 Register" ] pub struct ECC_PR9 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 9 Register" ] pub mod ecc_pr9 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR9 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 10 Register" ] pub struct ECC_PR10 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 10 Register" ] pub mod ecc_pr10 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR10 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 11 Register" ] pub struct ECC_PR11 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 11 Register" ] pub mod ecc_pr11 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR11 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 12 Register" ] pub struct ECC_PR12 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 12 Register" ] pub mod ecc_pr12 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR12 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 13 Register" ] pub struct ECC_PR13 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 13 Register" ] pub mod ecc_pr13 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR13 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 14 Register" ] pub struct ECC_PR14 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 14 Register" ] pub mod ecc_pr14 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR14 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC ECC parity 15 Register" ] pub struct ECC_PR15 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC ECC parity 15 Register" ] pub mod ecc_pr15 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ECC_PR15 { # [ 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 BITADDRR { bits : u8 , } impl BITADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WORDADDRR { bits : u8 , } impl WORDADDRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NPARITYR { bits : u16 , } impl NPARITYR { # [ 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:2 - Corrupted Bit Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn bitaddr ( & self ) -> BITADDRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; BITADDRR { bits } } # [ doc = "Bits 3:10 - Corrupted Word Address in the Page between (i x 256) and ((i + 1) x 512) - 1) Bytes" ] # [ inline ] pub fn wordaddr ( & self ) -> WORDADDRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WORDADDRR { bits } } # [ doc = "Bits 12:22 - Parity N" ] # [ inline ] pub fn nparity ( & self ) -> NPARITYR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NPARITYR { bits } } } } # [ doc = "SMC Setup Register (CS_number = 0)" ] pub struct SETUP0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 0)" ] pub mod setup0 { # [ 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 :: SETUP0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 0)" ] pub struct PULSE0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 0)" ] pub mod pulse0 { # [ 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 :: PULSE0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 0)" ] pub struct CYCLE0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 0)" ] pub mod cycle0 { # [ 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 :: CYCLE0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 0)" ] pub struct TIMINGS0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 0)" ] pub mod timings0 { # [ 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 :: TIMINGS0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 0)" ] pub struct MODE0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 0)" ] pub mod mode0 { # [ 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 :: MODE0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC Setup Register (CS_number = 1)" ] pub struct SETUP1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 1)" ] pub mod setup1 { # [ 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 :: SETUP1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 1)" ] pub struct PULSE1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 1)" ] pub mod pulse1 { # [ 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 :: PULSE1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 1)" ] pub struct CYCLE1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 1)" ] pub mod cycle1 { # [ 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 :: CYCLE1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 1)" ] pub struct TIMINGS1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 1)" ] pub mod timings1 { # [ 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 :: TIMINGS1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 1)" ] pub struct MODE1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 1)" ] pub mod mode1 { # [ 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 :: MODE1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC Setup Register (CS_number = 2)" ] pub struct SETUP2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 2)" ] pub mod setup2 { # [ 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 :: SETUP2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 2)" ] pub struct PULSE2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 2)" ] pub mod pulse2 { # [ 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 :: PULSE2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 2)" ] pub struct CYCLE2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 2)" ] pub mod cycle2 { # [ 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 :: CYCLE2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 2)" ] pub struct TIMINGS2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 2)" ] pub mod timings2 { # [ 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 :: TIMINGS2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 2)" ] pub struct MODE2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 2)" ] pub mod mode2 { # [ 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 :: MODE2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC Setup Register (CS_number = 3)" ] pub struct SETUP3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 3)" ] pub mod setup3 { # [ 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 :: SETUP3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 3)" ] pub struct PULSE3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 3)" ] pub mod pulse3 { # [ 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 :: PULSE3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 3)" ] pub struct CYCLE3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 3)" ] pub mod cycle3 { # [ 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 :: CYCLE3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 3)" ] pub struct TIMINGS3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 3)" ] pub mod timings3 { # [ 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 :: TIMINGS3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 3)" ] pub struct MODE3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 3)" ] pub mod mode3 { # [ 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 :: MODE3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC Setup Register (CS_number = 4)" ] pub struct SETUP4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 4)" ] pub mod setup4 { # [ 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 :: SETUP4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 4)" ] pub struct PULSE4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 4)" ] pub mod pulse4 { # [ 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 :: PULSE4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 4)" ] pub struct CYCLE4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 4)" ] pub mod cycle4 { # [ 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 :: CYCLE4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 4)" ] pub struct TIMINGS4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 4)" ] pub mod timings4 { # [ 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 :: TIMINGS4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 4)" ] pub struct MODE4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 4)" ] pub mod mode4 { # [ 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 :: MODE4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC Setup Register (CS_number = 5)" ] pub struct SETUP5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 5)" ] pub mod setup5 { # [ 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 :: SETUP5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 5)" ] pub struct PULSE5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 5)" ] pub mod pulse5 { # [ 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 :: PULSE5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 5)" ] pub struct CYCLE5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 5)" ] pub mod cycle5 { # [ 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 :: CYCLE5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 5)" ] pub struct TIMINGS5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 5)" ] pub mod timings5 { # [ 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 :: TIMINGS5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 5)" ] pub struct MODE5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 5)" ] pub mod mode5 { # [ 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 :: MODE5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC Setup Register (CS_number = 6)" ] pub struct SETUP6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 6)" ] pub mod setup6 { # [ 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 :: SETUP6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 6)" ] pub struct PULSE6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 6)" ] pub mod pulse6 { # [ 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 :: PULSE6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 6)" ] pub struct CYCLE6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 6)" ] pub mod cycle6 { # [ 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 :: CYCLE6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 6)" ] pub struct TIMINGS6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 6)" ] pub mod timings6 { # [ 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 :: TIMINGS6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 6)" ] pub struct MODE6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 6)" ] pub mod mode6 { # [ 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 :: MODE6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC Setup Register (CS_number = 7)" ] pub struct SETUP7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Setup Register (CS_number = 7)" ] pub mod setup7 { # [ 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 :: SETUP7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_SETUPR { bits : u8 , } impl NWE_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_SETUPR { bits : u8 , } impl NCS_WR_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_SETUPR { bits : u8 , } impl NRD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_SETUPR { bits : u8 , } impl NCS_RD_SETUPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_WR_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NRD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _NCS_RD_SETUPW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_SETUPW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & self ) -> NWE_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_SETUPR { bits } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & self ) -> NCS_WR_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_SETUPR { bits } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & self ) -> NRD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_SETUPR { bits } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & self ) -> NCS_RD_SETUPR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_SETUPR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:5 - NWE Setup Length" ] # [ inline ] pub fn nwe_setup ( & mut self ) -> _NWE_SETUPW { _NWE_SETUPW { w : self } } # [ doc = "Bits 8:13 - NCS Setup Length in Write Access" ] # [ inline ] pub fn ncs_wr_setup ( & mut self ) -> _NCS_WR_SETUPW { _NCS_WR_SETUPW { w : self } } # [ doc = "Bits 16:21 - NRD Setup Length" ] # [ inline ] pub fn nrd_setup ( & mut self ) -> _NRD_SETUPW { _NRD_SETUPW { w : self } } # [ doc = "Bits 24:29 - NCS Setup Length in Read Access" ] # [ inline ] pub fn ncs_rd_setup ( & mut self ) -> _NCS_RD_SETUPW { _NCS_RD_SETUPW { w : self } } } } # [ doc = "SMC Pulse Register (CS_number = 7)" ] pub struct PULSE7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Pulse Register (CS_number = 7)" ] pub mod pulse7 { # [ 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 :: PULSE7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_PULSER { bits : u8 , } impl NWE_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_WR_PULSER { bits : u8 , } impl NCS_WR_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NRD_PULSER { bits : u8 , } impl NRD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NCS_RD_PULSER { bits : u8 , } impl NCS_RD_PULSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_PULSEW < '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 } } # [ doc = r" Proxy" ] pub struct _NCS_WR_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_WR_PULSEW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _NRD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_PULSEW < '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 _NCS_RD_PULSEW < 'a > { w : & 'a mut W , } impl < 'a > _NCS_RD_PULSEW < '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 = 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 = "Bits 0:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & self ) -> NWE_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NWE_PULSER { bits } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & self ) -> NCS_WR_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_WR_PULSER { bits } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & self ) -> NRD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NRD_PULSER { bits } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & self ) -> NCS_RD_PULSER { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; NCS_RD_PULSER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_0101 } } # [ 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:6 - NWE Pulse Length" ] # [ inline ] pub fn nwe_pulse ( & mut self ) -> _NWE_PULSEW { _NWE_PULSEW { w : self } } # [ doc = "Bits 8:14 - NCS Pulse Length in WRITE Access" ] # [ inline ] pub fn ncs_wr_pulse ( & mut self ) -> _NCS_WR_PULSEW { _NCS_WR_PULSEW { w : self } } # [ doc = "Bits 16:22 - NRD Pulse Length" ] # [ inline ] pub fn nrd_pulse ( & mut self ) -> _NRD_PULSEW { _NRD_PULSEW { w : self } } # [ doc = "Bits 24:30 - NCS Pulse Length in READ Access" ] # [ inline ] pub fn ncs_rd_pulse ( & mut self ) -> _NCS_RD_PULSEW { _NCS_RD_PULSEW { w : self } } } } # [ doc = "SMC Cycle Register (CS_number = 7)" ] pub struct CYCLE7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Cycle Register (CS_number = 7)" ] pub mod cycle7 { # [ 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 :: CYCLE7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 NWE_CYCLER { bits : u16 , } impl NWE_CYCLER { # [ 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 NRD_CYCLER { bits : u16 , } impl NRD_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _NWE_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NWE_CYCLEW < '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 } } # [ doc = r" Proxy" ] pub struct _NRD_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _NRD_CYCLEW < '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 = 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:8 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & self ) -> NWE_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NWE_CYCLER { bits } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & self ) -> NRD_CYCLER { let bits = { const MASK : u16 = 0x01ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; NRD_CYCLER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0003_0003 } } # [ 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 - Total Write Cycle Length" ] # [ inline ] pub fn nwe_cycle ( & mut self ) -> _NWE_CYCLEW { _NWE_CYCLEW { w : self } } # [ doc = "Bits 16:24 - Total Read Cycle Length" ] # [ inline ] pub fn nrd_cycle ( & mut self ) -> _NRD_CYCLEW { _NRD_CYCLEW { w : self } } } } # [ doc = "SMC Timings Register (CS_number = 7)" ] pub struct TIMINGS7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Timings Register (CS_number = 7)" ] pub mod timings7 { # [ 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 :: TIMINGS7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TCLRR { bits : u8 , } impl TCLRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TADLR { bits : u8 , } impl TADLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TARR { bits : u8 , } impl TARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct OCMSR { bits : bool , } impl OCMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TRRR { bits : u8 , } impl TRRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TWBR { bits : u8 , } impl TWBR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RBNSELR { bits : u8 , } impl RBNSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct NFSELR { bits : bool , } impl NFSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _TCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TCLRW < '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 } } # [ doc = r" Proxy" ] pub struct _TADLW < 'a > { w : & 'a mut W , } impl < 'a > _TADLW < '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 _TARW < 'a > { w : & 'a mut W , } impl < 'a > _TARW < '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 _OCMSW < 'a > { w : & 'a mut W , } impl < 'a > _OCMSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TRRW < 'a > { w : & 'a mut W , } impl < 'a > _TRRW < '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 _TWBW < 'a > { w : & 'a mut W , } impl < 'a > _TWBW < '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 _RBNSELW < 'a > { w : & 'a mut W , } impl < 'a > _RBNSELW < '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 _NFSELW < 'a > { w : & 'a mut W , } impl < 'a > _NFSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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:3 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & self ) -> TCLRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TCLRR { bits } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & self ) -> TADLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TADLR { bits } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & self ) -> TARR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TARR { bits } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & self ) -> OCMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OCMSR { bits } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & self ) -> TRRR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TRRR { bits } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & self ) -> TWBR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TWBR { bits } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & self ) -> RBNSELR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RBNSELR { bits } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & self ) -> NFSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NFSELR { 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 - CLE to REN Low Delay" ] # [ inline ] pub fn tclr ( & mut self ) -> _TCLRW { _TCLRW { w : self } } # [ doc = "Bits 4:7 - ALE to Data Start" ] # [ inline ] pub fn tadl ( & mut self ) -> _TADLW { _TADLW { w : self } } # [ doc = "Bits 8:11 - ALE to REN Low Delay" ] # [ inline ] pub fn tar ( & mut self ) -> _TARW { _TARW { w : self } } # [ doc = "Bit 12 - Off Chip Memory Scrambling Enable" ] # [ inline ] pub fn ocms ( & mut self ) -> _OCMSW { _OCMSW { w : self } } # [ doc = "Bits 16:19 - Ready to REN Low Delay" ] # [ inline ] pub fn trr ( & mut self ) -> _TRRW { _TRRW { w : self } } # [ doc = "Bits 24:27 - WEN High to REN to Busy" ] # [ inline ] pub fn twb ( & mut self ) -> _TWBW { _TWBW { w : self } } # [ doc = "Bits 28:30 - Ready/Busy Line Selection" ] # [ inline ] pub fn rbnsel ( & mut self ) -> _RBNSELW { _RBNSELW { w : self } } # [ doc = "Bit 31 - NAND Flash Selection" ] # [ inline ] pub fn nfsel ( & mut self ) -> _NFSELW { _NFSELW { w : self } } } } # [ doc = "SMC Mode Register (CS_number = 7)" ] pub struct MODE7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC Mode Register (CS_number = 7)" ] pub mod mode7 { # [ 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 :: MODE7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `READ_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum READ_MODER { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { READ_MODER :: NCS_CTRL => false , READ_MODER :: NRD_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> READ_MODER { match value { false => READ_MODER :: NCS_CTRL , true => READ_MODER :: NRD_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == READ_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NRD_CTRL`" ] # [ inline ] pub fn is_nrd_ctrl ( & self ) -> bool { * self == READ_MODER :: NRD_CTRL } } # [ doc = "Possible values of the field `WRITE_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WRITE_MODER { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODER { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WRITE_MODER :: NCS_CTRL => false , WRITE_MODER :: NWE_CTRL => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WRITE_MODER { match value { false => WRITE_MODER :: NCS_CTRL , true => WRITE_MODER :: NWE_CTRL , } } # [ doc = "Checks if the value of the field is `NCS_CTRL`" ] # [ inline ] pub fn is_ncs_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NCS_CTRL } # [ doc = "Checks if the value of the field is `NWE_CTRL`" ] # [ inline ] pub fn is_nwe_ctrl ( & self ) -> bool { * self == WRITE_MODER :: NWE_CTRL } } # [ doc = "Possible values of the field `EXNW_MODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EXNW_MODER { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EXNW_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EXNW_MODER :: DISABLED => 0 , EXNW_MODER :: FROZEN => 0x02 , EXNW_MODER :: READY => 0x03 , EXNW_MODER :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EXNW_MODER { match value { 0 => EXNW_MODER :: DISABLED , 2 => EXNW_MODER :: FROZEN , 3 => EXNW_MODER :: READY , i => EXNW_MODER :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `DISABLED`" ] # [ inline ] pub fn is_disabled ( & self ) -> bool { * self == EXNW_MODER :: DISABLED } # [ doc = "Checks if the value of the field is `FROZEN`" ] # [ inline ] pub fn is_frozen ( & self ) -> bool { * self == EXNW_MODER :: FROZEN } # [ doc = "Checks if the value of the field is `READY`" ] # [ inline ] pub fn is_ready ( & self ) -> bool { * self == EXNW_MODER :: READY } } # [ doc = r" Value of the field" ] pub struct BATR { bits : bool , } impl BATR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DBW`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DBWR { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { DBWR :: BIT_8 => false , DBWR :: BIT_16 => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> DBWR { match value { false => DBWR :: BIT_8 , true => DBWR :: BIT_16 , } } # [ doc = "Checks if the value of the field is `BIT_8`" ] # [ inline ] pub fn is_bit_8 ( & self ) -> bool { * self == DBWR :: BIT_8 } # [ doc = "Checks if the value of the field is `BIT_16`" ] # [ inline ] pub fn is_bit_16 ( & self ) -> bool { * self == DBWR :: BIT_16 } } # [ doc = r" Value of the field" ] pub struct TDF_CYCLESR { bits : u8 , } impl TDF_CYCLESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct TDF_MODER { bits : bool , } impl TDF_MODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `READ_MODE`" ] pub enum READ_MODEW { # [ doc = "The Read operation is controlled by the NCS signal." ] NCS_CTRL , # [ doc = "The Read operation is controlled by the NRD signal." ] NRD_CTRL } impl READ_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { READ_MODEW :: NCS_CTRL => false , READ_MODEW :: NRD_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _READ_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _READ_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : READ_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Read operation is controlled by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NCS_CTRL ) } # [ doc = "The Read operation is controlled by the NRD signal." ] # [ inline ] pub fn nrd_ctrl ( self ) -> & 'a mut W { self . variant ( READ_MODEW :: NRD_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WRITE_MODE`" ] pub enum WRITE_MODEW { # [ doc = "The Write operation is controller by the NCS signal." ] NCS_CTRL , # [ doc = "The Write operation is controlled by the NWE signal." ] NWE_CTRL } impl WRITE_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WRITE_MODEW :: NCS_CTRL => false , WRITE_MODEW :: NWE_CTRL => true } } } # [ doc = r" Proxy" ] pub struct _WRITE_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _WRITE_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WRITE_MODEW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "The Write operation is controller by the NCS signal." ] # [ inline ] pub fn ncs_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NCS_CTRL ) } # [ doc = "The Write operation is controlled by the NWE signal." ] # [ inline ] pub fn nwe_ctrl ( self ) -> & 'a mut W { self . variant ( WRITE_MODEW :: NWE_CTRL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `EXNW_MODE`" ] pub enum EXNW_MODEW { # [ doc = "Disabled" ] DISABLED , # [ doc = "Frozen Mode" ] FROZEN , # [ doc = "Ready Mode" ] READY } impl EXNW_MODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { EXNW_MODEW :: DISABLED => 0 , EXNW_MODEW :: FROZEN => 2 , EXNW_MODEW :: READY => 3 } } } # [ doc = r" Proxy" ] pub struct _EXNW_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _EXNW_MODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : EXNW_MODEW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Disabled" ] # [ inline ] pub fn disabled ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: DISABLED ) } # [ doc = "Frozen Mode" ] # [ inline ] pub fn frozen ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: FROZEN ) } # [ doc = "Ready Mode" ] # [ inline ] pub fn ready ( self ) -> & 'a mut W { self . variant ( EXNW_MODEW :: READY ) } # [ 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 _BATW < 'a > { w : & 'a mut W , } impl < 'a > _BATW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DBW`" ] pub enum DBWW { # [ doc = "8-bit bus" ] BIT_8 , # [ doc = "16-bit bus" ] BIT_16 } impl DBWW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { DBWW :: BIT_8 => false , DBWW :: BIT_16 => true } } } # [ doc = r" Proxy" ] pub struct _DBWW < 'a > { w : & 'a mut W , } impl < 'a > _DBWW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DBWW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "8-bit bus" ] # [ inline ] pub fn bit_8 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_8 ) } # [ doc = "16-bit bus" ] # [ inline ] pub fn bit_16 ( self ) -> & 'a mut W { self . variant ( DBWW :: BIT_16 ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TDF_CYCLESW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_CYCLESW < '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 _TDF_MODEW < 'a > { w : & 'a mut W , } impl < 'a > _TDF_MODEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & self ) -> READ_MODER { READ_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & self ) -> WRITE_MODER { WRITE_MODER :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & self ) -> EXNW_MODER { EXNW_MODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & self ) -> BATR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; BATR { bits } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & self ) -> DBWR { DBWR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & self ) -> TDF_CYCLESR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; TDF_CYCLESR { bits } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & self ) -> TDF_MODER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TDF_MODER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1000_0003 } } # [ 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 - Selection of the Control Signal for Read Operation" ] # [ inline ] pub fn read_mode ( & mut self ) -> _READ_MODEW { _READ_MODEW { w : self } } # [ doc = "Bit 1 - Selection of the Control Signal for Write Operation" ] # [ inline ] pub fn write_mode ( & mut self ) -> _WRITE_MODEW { _WRITE_MODEW { w : self } } # [ doc = "Bits 4:5 - NWAIT Mode" ] # [ inline ] pub fn exnw_mode ( & mut self ) -> _EXNW_MODEW { _EXNW_MODEW { w : self } } # [ doc = "Bit 8 - Byte Access Type" ] # [ inline ] pub fn bat ( & mut self ) -> _BATW { _BATW { w : self } } # [ doc = "Bit 12 - Data Bus Width" ] # [ inline ] pub fn dbw ( & mut self ) -> _DBWW { _DBWW { w : self } } # [ doc = "Bits 16:19 - Data Float Time" ] # [ inline ] pub fn tdf_cycles ( & mut self ) -> _TDF_CYCLESW { _TDF_CYCLESW { w : self } } # [ doc = "Bit 20 - TDF Optimization" ] # [ inline ] pub fn tdf_mode ( & mut self ) -> _TDF_MODEW { _TDF_MODEW { w : self } } } } # [ doc = "SMC OCMS Register" ] pub struct OCMS { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC OCMS Register" ] pub mod ocms { # [ 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 :: OCMS { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SMSER { bits : bool , } impl SMSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SRSER { bits : bool , } impl SRSER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SMSEW < 'a > { w : & 'a mut W , } impl < 'a > _SMSEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SRSEW < 'a > { w : & 'a mut W , } impl < 'a > _SRSEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Static Memory Controller Scrambling Enable" ] # [ inline ] pub fn smse ( & self ) -> SMSER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SMSER { bits } } # [ doc = "Bit 1 - SRAM Scrambling Enable" ] # [ inline ] pub fn srse ( & self ) -> SRSER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SRSER { 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 - Static Memory Controller Scrambling Enable" ] # [ inline ] pub fn smse ( & mut self ) -> _SMSEW { _SMSEW { w : self } } # [ doc = "Bit 1 - SRAM Scrambling Enable" ] # [ inline ] pub fn srse ( & mut self ) -> _SRSEW { _SRSEW { w : self } } } } # [ doc = "SMC OCMS KEY1 Register" ] pub struct KEY1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC OCMS KEY1 Register" ] pub mod key1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: KEY1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _KEY1W < 'a > { w : & 'a mut W , } impl < 'a > _KEY1W < '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 - Off Chip Memory Scrambling (OCMS) Key Part 1" ] # [ inline ] pub fn key1 ( & mut self ) -> _KEY1W { _KEY1W { w : self } } } } # [ doc = "SMC OCMS KEY2 Register" ] pub struct KEY2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "SMC OCMS KEY2 Register" ] pub mod key2 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: KEY2 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _KEY2W < 'a > { w : & 'a mut W , } impl < 'a > _KEY2W < '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 - Off Chip Memory Scrambling (OCMS) Key Part 2" ] # [ inline ] pub fn key2 ( & mut self ) -> _KEY2W { _KEY2W { w : self } } } } # [ doc = "Write Protection Control Register" ] pub struct WPCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Control Register" ] pub mod wpcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: WPCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _WP_ENW < 'a > { w : & 'a mut W , } impl < 'a > _WP_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 = "Values that can be written to the field `WP_KEY`" ] pub enum WP_KEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WP_EN bit. Always reads as 0." ] PASSWD } impl WP_KEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WP_KEYW :: PASSWD => 5459267 } } } # [ doc = r" Proxy" ] pub struct _WP_KEYW < 'a > { w : & 'a mut W , } impl < 'a > _WP_KEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WP_KEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WP_EN bit. Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WP_KEYW :: PASSWD ) } # [ 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 = 8 ; 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 - Write Protection Enable" ] # [ inline ] pub fn wp_en ( & mut self ) -> _WP_ENW { _WP_ENW { w : self } } # [ doc = "Bits 8:31 - Write Protection KEY Password" ] # [ inline ] pub fn wp_key ( & mut self ) -> _WP_KEYW { _WP_KEYW { w : self } } } } # [ doc = "Write Protection Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protection Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WP_VSR { bits : u8 , } impl WP_VSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct WP_VSRCR { bits : u16 , } impl WP_VSRCR { # [ 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:3 - Write Protection Violation Status" ] # [ inline ] pub fn wp_vs ( & self ) -> WP_VSR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; WP_VSR { bits } } # [ doc = "Bits 8:23 - Write Protection Violation Source" ] # [ inline ] pub fn wp_vsrc ( & self ) -> WP_VSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WP_VSRCR { bits } } } } } # [ doc = "AHB Bus Matrix" ] pub struct MATRIX { _marker : PhantomData < * const ( ) > } unsafe impl Send for MATRIX { } impl MATRIX { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const matrix :: RegisterBlock { 0x400e_0400 as * const _ } } impl Deref for MATRIX { type Target = matrix :: RegisterBlock ; fn deref ( & self ) -> & matrix :: RegisterBlock { unsafe { & * MATRIX :: ptr ( ) } } } # [ doc = "AHB Bus Matrix" ] pub mod matrix { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Master Configuration Register" ] pub matrix_mcfg : [ MATRIX_MCFG ; 6 ] , _reserved1 : [ u8 ; 40usize ] , # [ doc = "0x40 - Slave Configuration Register" ] pub matrix_scfg : [ MATRIX_SCFG ; 9 ] , _reserved2 : [ u8 ; 28usize ] , # [ doc = "0x80 - Priority Register A for Slave 0" ] pub matrix_pras0 : MATRIX_PRAS0 , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x88 - Priority Register A for Slave 1" ] pub matrix_pras1 : MATRIX_PRAS1 , _reserved4 : [ u8 ; 4usize ] , # [ doc = "0x90 - Priority Register A for Slave 2" ] pub matrix_pras2 : MATRIX_PRAS2 , _reserved5 : [ u8 ; 4usize ] , # [ doc = "0x98 - Priority Register A for Slave 3" ] pub matrix_pras3 : MATRIX_PRAS3 , _reserved6 : [ u8 ; 4usize ] , # [ doc = "0xa0 - Priority Register A for Slave 4" ] pub matrix_pras4 : MATRIX_PRAS4 , _reserved7 : [ u8 ; 4usize ] , # [ doc = "0xa8 - Priority Register A for Slave 5" ] pub matrix_pras5 : MATRIX_PRAS5 , _reserved8 : [ u8 ; 4usize ] , # [ doc = "0xb0 - Priority Register A for Slave 6" ] pub matrix_pras6 : MATRIX_PRAS6 , _reserved9 : [ u8 ; 4usize ] , # [ doc = "0xb8 - Priority Register A for Slave 7" ] pub matrix_pras7 : MATRIX_PRAS7 , _reserved10 : [ u8 ; 4usize ] , # [ doc = "0xc0 - Priority Register A for Slave 8" ] pub matrix_pras8 : MATRIX_PRAS8 , _reserved11 : [ u8 ; 60usize ] , # [ doc = "0x100 - Master Remap Control Register" ] pub matrix_mrcr : MATRIX_MRCR , _reserved12 : [ u8 ; 16usize ] , # [ doc = "0x114 - System I/O Configuration register" ] pub ccfg_sysio : CCFG_SYSIO , _reserved13 : [ u8 ; 204usize ] , # [ doc = "0x1e4 - Write Protect Mode Register" ] pub matrix_wpmr : MATRIX_WPMR , # [ doc = "0x1e8 - Write Protect Status Register" ] pub matrix_wpsr : MATRIX_WPSR , } # [ doc = "Master Configuration Register" ] pub struct MATRIX_MCFG { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Master Configuration Register" ] pub mod matrix_mcfg { # [ 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 :: MATRIX_MCFG { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 ULBTR { bits : u8 , } impl ULBTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _ULBTW < 'a > { w : & 'a mut W , } impl < 'a > _ULBTW < '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 - Undefined Length Burst Type" ] # [ inline ] pub fn ulbt ( & self ) -> ULBTR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; ULBTR { bits } } } impl W { # [ doc = "Bits 0:2 - Undefined Length Burst Type" ] # [ inline ] pub fn ulbt ( & mut self ) -> _ULBTW { _ULBTW { w : self } } } } # [ doc = "Slave Configuration Register" ] pub struct MATRIX_SCFG { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Slave Configuration Register" ] pub mod matrix_scfg { # [ 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 :: MATRIX_SCFG { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 SLOT_CYCLER { bits : u8 , } impl SLOT_CYCLER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DEFMSTR_TYPER { bits : u8 , } impl DEFMSTR_TYPER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct FIXED_DEFMSTRR { bits : u8 , } impl FIXED_DEFMSTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct ARBTR { bits : u8 , } impl ARBTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _SLOT_CYCLEW < 'a > { w : & 'a mut W , } impl < 'a > _SLOT_CYCLEW < '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 _DEFMSTR_TYPEW < 'a > { w : & 'a mut W , } impl < 'a > _DEFMSTR_TYPEW < '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 _FIXED_DEFMSTRW < 'a > { w : & 'a mut W , } impl < 'a > _FIXED_DEFMSTRW < '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 = 18 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _ARBTW < 'a > { w : & 'a mut W , } impl < 'a > _ARBTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:7 - Maximum Number of Allowed Cycles for a Burst" ] # [ inline ] pub fn slot_cycle ( & self ) -> SLOT_CYCLER { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SLOT_CYCLER { bits } } # [ doc = "Bits 16:17 - Default Master Type" ] # [ inline ] pub fn defmstr_type ( & self ) -> DEFMSTR_TYPER { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DEFMSTR_TYPER { bits } } # [ doc = "Bits 18:20 - Fixed Default Master" ] # [ inline ] pub fn fixed_defmstr ( & self ) -> FIXED_DEFMSTRR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FIXED_DEFMSTRR { bits } } # [ doc = "Bits 24:25 - Arbitration Type" ] # [ inline ] pub fn arbt ( & self ) -> ARBTR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; ARBTR { bits } } } impl W { # [ doc = "Bits 0:7 - Maximum Number of Allowed Cycles for a Burst" ] # [ inline ] pub fn slot_cycle ( & mut self ) -> _SLOT_CYCLEW { _SLOT_CYCLEW { w : self } } # [ doc = "Bits 16:17 - Default Master Type" ] # [ inline ] pub fn defmstr_type ( & mut self ) -> _DEFMSTR_TYPEW { _DEFMSTR_TYPEW { w : self } } # [ doc = "Bits 18:20 - Fixed Default Master" ] # [ inline ] pub fn fixed_defmstr ( & mut self ) -> _FIXED_DEFMSTRW { _FIXED_DEFMSTRW { w : self } } # [ doc = "Bits 24:25 - Arbitration Type" ] # [ inline ] pub fn arbt ( & mut self ) -> _ARBTW { _ARBTW { w : self } } } } # [ doc = "Priority Register A for Slave 0" ] pub struct MATRIX_PRAS0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 0" ] pub mod matrix_pras0 { # [ 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 :: MATRIX_PRAS0 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 1" ] pub struct MATRIX_PRAS1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 1" ] pub mod matrix_pras1 { # [ 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 :: MATRIX_PRAS1 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 2" ] pub struct MATRIX_PRAS2 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 2" ] pub mod matrix_pras2 { # [ 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 :: MATRIX_PRAS2 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 3" ] pub struct MATRIX_PRAS3 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 3" ] pub mod matrix_pras3 { # [ 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 :: MATRIX_PRAS3 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 4" ] pub struct MATRIX_PRAS4 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 4" ] pub mod matrix_pras4 { # [ 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 :: MATRIX_PRAS4 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 5" ] pub struct MATRIX_PRAS5 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 5" ] pub mod matrix_pras5 { # [ 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 :: MATRIX_PRAS5 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 6" ] pub struct MATRIX_PRAS6 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 6" ] pub mod matrix_pras6 { # [ 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 :: MATRIX_PRAS6 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 7" ] pub struct MATRIX_PRAS7 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 7" ] pub mod matrix_pras7 { # [ 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 :: MATRIX_PRAS7 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Priority Register A for Slave 8" ] pub struct MATRIX_PRAS8 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Priority Register A for Slave 8" ] pub mod matrix_pras8 { # [ 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 :: MATRIX_PRAS8 { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 M0PRR { bits : u8 , } impl M0PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M1PRR { bits : u8 , } impl M1PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M2PRR { bits : u8 , } impl M2PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M3PRR { bits : u8 , } impl M3PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M4PRR { bits : u8 , } impl M4PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct M5PRR { bits : u8 , } impl M5PRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _M0PRW < 'a > { w : & 'a mut W , } impl < 'a > _M0PRW < '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 _M1PRW < 'a > { w : & 'a mut W , } impl < 'a > _M1PRW < '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 _M2PRW < 'a > { w : & 'a mut W , } impl < 'a > _M2PRW < '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 _M3PRW < 'a > { w : & 'a mut W , } impl < 'a > _M3PRW < '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 _M4PRW < 'a > { w : & 'a mut W , } impl < 'a > _M4PRW < '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 _M5PRW < 'a > { w : & 'a mut W , } impl < 'a > _M5PRW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & self ) -> M0PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M0PRR { bits } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & self ) -> M1PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M1PRR { bits } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & self ) -> M2PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M2PRR { bits } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & self ) -> M3PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M3PRR { bits } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & self ) -> M4PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M4PRR { bits } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & self ) -> M5PRR { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; M5PRR { 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 - Master 0 Priority" ] # [ inline ] pub fn m0pr ( & mut self ) -> _M0PRW { _M0PRW { w : self } } # [ doc = "Bits 4:5 - Master 1 Priority" ] # [ inline ] pub fn m1pr ( & mut self ) -> _M1PRW { _M1PRW { w : self } } # [ doc = "Bits 8:9 - Master 2 Priority" ] # [ inline ] pub fn m2pr ( & mut self ) -> _M2PRW { _M2PRW { w : self } } # [ doc = "Bits 12:13 - Master 3 Priority" ] # [ inline ] pub fn m3pr ( & mut self ) -> _M3PRW { _M3PRW { w : self } } # [ doc = "Bits 16:17 - Master 4 Priority" ] # [ inline ] pub fn m4pr ( & mut self ) -> _M4PRW { _M4PRW { w : self } } # [ doc = "Bits 20:21 - Master 5 Priority" ] # [ inline ] pub fn m5pr ( & mut self ) -> _M5PRW { _M5PRW { w : self } } } } # [ doc = "Master Remap Control Register" ] pub struct MATRIX_MRCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Master Remap Control Register" ] pub mod matrix_mrcr { # [ 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 :: MATRIX_MRCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RCB0R { bits : bool , } impl RCB0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCB1R { bits : bool , } impl RCB1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCB2R { bits : bool , } impl RCB2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCB3R { bits : bool , } impl RCB3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RCB4R { bits : u8 , } impl RCB4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct RCB5R { bits : bool , } impl RCB5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _RCB0W < 'a > { w : & 'a mut W , } impl < 'a > _RCB0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCB1W < 'a > { w : & 'a mut W , } impl < 'a > _RCB1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCB2W < 'a > { w : & 'a mut W , } impl < 'a > _RCB2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCB3W < 'a > { w : & 'a mut W , } impl < 'a > _RCB3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RCB4W < 'a > { w : & 'a mut W , } impl < 'a > _RCB4W < '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 _RCB5W < 'a > { w : & 'a mut W , } impl < 'a > _RCB5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Remap Command Bit for AHB Master 0" ] # [ inline ] pub fn rcb0 ( & self ) -> RCB0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCB0R { bits } } # [ doc = "Bit 1 - Remap Command Bit for AHB Master 1" ] # [ inline ] pub fn rcb1 ( & self ) -> RCB1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCB1R { bits } } # [ doc = "Bit 2 - Remap Command Bit for AHB Master 2" ] # [ inline ] pub fn rcb2 ( & self ) -> RCB2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCB2R { bits } } # [ doc = "Bit 3 - Remap Command Bit for AHB Master 3" ] # [ inline ] pub fn rcb3 ( & self ) -> RCB3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCB3R { bits } } # [ doc = "Bits 4:5 - Remap Command Bit for AHB Master 4" ] # [ inline ] pub fn rcb4 ( & self ) -> RCB4R { let bits = { const MASK : u8 = 0x03 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RCB4R { bits } } # [ doc = "Bit 6 - Remap Command Bit for AHB Master 5" ] # [ inline ] pub fn rcb5 ( & self ) -> RCB5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RCB5R { 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 - Remap Command Bit for AHB Master 0" ] # [ inline ] pub fn rcb0 ( & mut self ) -> _RCB0W { _RCB0W { w : self } } # [ doc = "Bit 1 - Remap Command Bit for AHB Master 1" ] # [ inline ] pub fn rcb1 ( & mut self ) -> _RCB1W { _RCB1W { w : self } } # [ doc = "Bit 2 - Remap Command Bit for AHB Master 2" ] # [ inline ] pub fn rcb2 ( & mut self ) -> _RCB2W { _RCB2W { w : self } } # [ doc = "Bit 3 - Remap Command Bit for AHB Master 3" ] # [ inline ] pub fn rcb3 ( & mut self ) -> _RCB3W { _RCB3W { w : self } } # [ doc = "Bits 4:5 - Remap Command Bit for AHB Master 4" ] # [ inline ] pub fn rcb4 ( & mut self ) -> _RCB4W { _RCB4W { w : self } } # [ doc = "Bit 6 - Remap Command Bit for AHB Master 5" ] # [ inline ] pub fn rcb5 ( & mut self ) -> _RCB5W { _RCB5W { w : self } } } } # [ doc = "System I/O Configuration register" ] pub struct CCFG_SYSIO { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System I/O Configuration register" ] pub mod ccfg_sysio { # [ 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 :: CCFG_SYSIO { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SYSIO12R { bits : bool , } impl SYSIO12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SYSIO12W < 'a > { w : & 'a mut W , } impl < 'a > _SYSIO12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 12 - PC0 or ERASE Assignment" ] # [ inline ] pub fn sysio12 ( & self ) -> SYSIO12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SYSIO12R { 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 - PC0 or ERASE Assignment" ] # [ inline ] pub fn sysio12 ( & mut self ) -> _SYSIO12W { _SYSIO12W { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct MATRIX_WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod matrix_wpmr { # [ 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 :: MATRIX_WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protect ENable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY (Write-only)" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protect ENable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY (Write-only)" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct MATRIX_WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod matrix_wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MATRIX_WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } } # [ doc = "Power Management Controller" ] pub struct PMC { _marker : PhantomData < * const ( ) > } unsafe impl Send for PMC { } impl PMC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const pmc :: RegisterBlock { 0x400e_0600 as * const _ } } impl Deref for PMC { type Target = pmc :: RegisterBlock ; fn deref ( & self ) -> & pmc :: RegisterBlock { unsafe { & * PMC :: ptr ( ) } } } # [ doc = "Power Management Controller" ] pub mod pmc { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - System Clock Enable Register" ] pub pmc_scer : PMC_SCER , # [ doc = "0x04 - System Clock Disable Register" ] pub pmc_scdr : PMC_SCDR , # [ doc = "0x08 - System Clock Status Register" ] pub pmc_scsr : PMC_SCSR , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Peripheral Clock Enable Register 0" ] pub pmc_pcer0 : PMC_PCER0 , # [ doc = "0x14 - Peripheral Clock Disable Register 0" ] pub pmc_pcdr0 : PMC_PCDR0 , # [ doc = "0x18 - Peripheral Clock Status Register 0" ] pub pmc_pcsr0 : PMC_PCSR0 , # [ doc = "0x1c - UTMI Clock Register" ] pub ckgr_uckr : CKGR_UCKR , # [ doc = "0x20 - Main Oscillator Register" ] pub ckgr_mor : CKGR_MOR , # [ doc = "0x24 - Main Clock Frequency Register" ] pub ckgr_mcfr : CKGR_MCFR , # [ doc = "0x28 - PLLA Register" ] pub ckgr_pllar : CKGR_PLLAR , _reserved10 : [ u8 ; 4usize ] , # [ doc = "0x30 - Master Clock Register" ] pub pmc_mckr : PMC_MCKR , _reserved11 : [ u8 ; 4usize ] , # [ doc = "0x38 - USB Clock Register" ] pub pmc_usb : PMC_USB , _reserved12 : [ u8 ; 4usize ] , # [ doc = "0x40 - Programmable Clock 0 Register" ] pub pmc_pck : [ PMC_PCK ; 3 ] , _reserved13 : [ u8 ; 20usize ] , # [ doc = "0x60 - Interrupt Enable Register" ] pub pmc_ier : PMC_IER , # [ doc = "0x64 - Interrupt Disable Register" ] pub pmc_idr : PMC_IDR , # [ doc = "0x68 - Status Register" ] pub pmc_sr : PMC_SR , # [ doc = "0x6c - Interrupt Mask Register" ] pub pmc_imr : PMC_IMR , # [ doc = "0x70 - Fast Start-up Mode Register" ] pub pmc_fsmr : PMC_FSMR , # [ doc = "0x74 - Fast Start-up Polarity Register" ] pub pmc_fspr : PMC_FSPR , # [ doc = "0x78 - Fault Output Clear Register" ] pub pmc_focr : PMC_FOCR , _reserved20 : [ u8 ; 104usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub pmc_wpmr : PMC_WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub pmc_wpsr : PMC_WPSR , _reserved22 : [ u8 ; 20usize ] , # [ doc = "0x100 - Peripheral Clock Enable Register 1" ] pub pmc_pcer1 : PMC_PCER1 , # [ doc = "0x104 - Peripheral Clock Disable Register 1" ] pub pmc_pcdr1 : PMC_PCDR1 , # [ doc = "0x108 - Peripheral Clock Status Register 1" ] pub pmc_pcsr1 : PMC_PCSR1 , # [ doc = "0x10c - Peripheral Control Register" ] pub pmc_pcr : PMC_PCR , } # [ doc = "System Clock Enable Register" ] pub struct PMC_SCER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System Clock Enable Register" ] pub mod pmc_scer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_SCER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _UOTGCLKW < 'a > { w : & 'a mut W , } impl < 'a > _UOTGCLKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCK0W < 'a > { w : & 'a mut W , } impl < 'a > _PCK0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCK1W < 'a > { w : & 'a mut W , } impl < 'a > _PCK1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCK2W < 'a > { w : & 'a mut W , } impl < 'a > _PCK2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 5 - Enable USB OTG Clock (48 MHz, USB_48M) for UTMI" ] # [ inline ] pub fn uotgclk ( & mut self ) -> _UOTGCLKW { _UOTGCLKW { w : self } } # [ doc = "Bit 8 - Programmable Clock 0 Output Enable" ] # [ inline ] pub fn pck0 ( & mut self ) -> _PCK0W { _PCK0W { w : self } } # [ doc = "Bit 9 - Programmable Clock 1 Output Enable" ] # [ inline ] pub fn pck1 ( & mut self ) -> _PCK1W { _PCK1W { w : self } } # [ doc = "Bit 10 - Programmable Clock 2 Output Enable" ] # [ inline ] pub fn pck2 ( & mut self ) -> _PCK2W { _PCK2W { w : self } } } } # [ doc = "System Clock Disable Register" ] pub struct PMC_SCDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System Clock Disable Register" ] pub mod pmc_scdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_SCDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _UOTGCLKW < 'a > { w : & 'a mut W , } impl < 'a > _UOTGCLKW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCK0W < 'a > { w : & 'a mut W , } impl < 'a > _PCK0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCK1W < 'a > { w : & 'a mut W , } impl < 'a > _PCK1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCK2W < 'a > { w : & 'a mut W , } impl < 'a > _PCK2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 5 - Disable USB OTG Clock (48 MHz, USB_48M) for UTMI" ] # [ inline ] pub fn uotgclk ( & mut self ) -> _UOTGCLKW { _UOTGCLKW { w : self } } # [ doc = "Bit 8 - Programmable Clock 0 Output Disable" ] # [ inline ] pub fn pck0 ( & mut self ) -> _PCK0W { _PCK0W { w : self } } # [ doc = "Bit 9 - Programmable Clock 1 Output Disable" ] # [ inline ] pub fn pck1 ( & mut self ) -> _PCK1W { _PCK1W { w : self } } # [ doc = "Bit 10 - Programmable Clock 2 Output Disable" ] # [ inline ] pub fn pck2 ( & mut self ) -> _PCK2W { _PCK2W { w : self } } } } # [ doc = "System Clock Status Register" ] pub struct PMC_SCSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System Clock Status Register" ] pub mod pmc_scsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PMC_SCSR { # [ 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 UOTGCLKR { bits : bool , } impl UOTGCLKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCK0R { bits : bool , } impl PCK0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCK1R { bits : bool , } impl PCK1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCK2R { bits : bool , } impl PCK2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 5 - USB OTG Clock (48 MHz, USB_48M) Clock Status" ] # [ inline ] pub fn uotgclk ( & self ) -> UOTGCLKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UOTGCLKR { bits } } # [ doc = "Bit 8 - Programmable Clock 0 Output Status" ] # [ inline ] pub fn pck0 ( & self ) -> PCK0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCK0R { bits } } # [ doc = "Bit 9 - Programmable Clock 1 Output Status" ] # [ inline ] pub fn pck1 ( & self ) -> PCK1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCK1R { bits } } # [ doc = "Bit 10 - Programmable Clock 2 Output Status" ] # [ inline ] pub fn pck2 ( & self ) -> PCK2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCK2R { bits } } } } # [ doc = "Peripheral Clock Enable Register 0" ] pub struct PMC_PCER0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral Clock Enable Register 0" ] pub mod pmc_pcer0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_PCER0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _PID8W < 'a > { w : & 'a mut W , } impl < 'a > _PID8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID9W < 'a > { w : & 'a mut W , } impl < 'a > _PID9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID10W < 'a > { w : & 'a mut W , } impl < 'a > _PID10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID11W < 'a > { w : & 'a mut W , } impl < 'a > _PID11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID12W < 'a > { w : & 'a mut W , } impl < 'a > _PID12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID13W < 'a > { w : & 'a mut W , } impl < 'a > _PID13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID14W < 'a > { w : & 'a mut W , } impl < 'a > _PID14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID15W < 'a > { w : & 'a mut W , } impl < 'a > _PID15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID16W < 'a > { w : & 'a mut W , } impl < 'a > _PID16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID17W < 'a > { w : & 'a mut W , } impl < 'a > _PID17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID18W < 'a > { w : & 'a mut W , } impl < 'a > _PID18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID19W < 'a > { w : & 'a mut W , } impl < 'a > _PID19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID20W < 'a > { w : & 'a mut W , } impl < 'a > _PID20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID21W < 'a > { w : & 'a mut W , } impl < 'a > _PID21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID22W < 'a > { w : & 'a mut W , } impl < 'a > _PID22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID23W < 'a > { w : & 'a mut W , } impl < 'a > _PID23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID24W < 'a > { w : & 'a mut W , } impl < 'a > _PID24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID25W < 'a > { w : & 'a mut W , } impl < 'a > _PID25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID26W < 'a > { w : & 'a mut W , } impl < 'a > _PID26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID27W < 'a > { w : & 'a mut W , } impl < 'a > _PID27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID28W < 'a > { w : & 'a mut W , } impl < 'a > _PID28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID29W < 'a > { w : & 'a mut W , } impl < 'a > _PID29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID30W < 'a > { w : & 'a mut W , } impl < 'a > _PID30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID31W < 'a > { w : & 'a mut W , } impl < 'a > _PID31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 8 - Peripheral Clock 8 Enable" ] # [ inline ] pub fn pid8 ( & mut self ) -> _PID8W { _PID8W { w : self } } # [ doc = "Bit 9 - Peripheral Clock 9 Enable" ] # [ inline ] pub fn pid9 ( & mut self ) -> _PID9W { _PID9W { w : self } } # [ doc = "Bit 10 - Peripheral Clock 10 Enable" ] # [ inline ] pub fn pid10 ( & mut self ) -> _PID10W { _PID10W { w : self } } # [ doc = "Bit 11 - Peripheral Clock 11 Enable" ] # [ inline ] pub fn pid11 ( & mut self ) -> _PID11W { _PID11W { w : self } } # [ doc = "Bit 12 - Peripheral Clock 12 Enable" ] # [ inline ] pub fn pid12 ( & mut self ) -> _PID12W { _PID12W { w : self } } # [ doc = "Bit 13 - Peripheral Clock 13 Enable" ] # [ inline ] pub fn pid13 ( & mut self ) -> _PID13W { _PID13W { w : self } } # [ doc = "Bit 14 - Peripheral Clock 14 Enable" ] # [ inline ] pub fn pid14 ( & mut self ) -> _PID14W { _PID14W { w : self } } # [ doc = "Bit 15 - Peripheral Clock 15 Enable" ] # [ inline ] pub fn pid15 ( & mut self ) -> _PID15W { _PID15W { w : self } } # [ doc = "Bit 16 - Peripheral Clock 16 Enable" ] # [ inline ] pub fn pid16 ( & mut self ) -> _PID16W { _PID16W { w : self } } # [ doc = "Bit 17 - Peripheral Clock 17 Enable" ] # [ inline ] pub fn pid17 ( & mut self ) -> _PID17W { _PID17W { w : self } } # [ doc = "Bit 18 - Peripheral Clock 18 Enable" ] # [ inline ] pub fn pid18 ( & mut self ) -> _PID18W { _PID18W { w : self } } # [ doc = "Bit 19 - Peripheral Clock 19 Enable" ] # [ inline ] pub fn pid19 ( & mut self ) -> _PID19W { _PID19W { w : self } } # [ doc = "Bit 20 - Peripheral Clock 20 Enable" ] # [ inline ] pub fn pid20 ( & mut self ) -> _PID20W { _PID20W { w : self } } # [ doc = "Bit 21 - Peripheral Clock 21 Enable" ] # [ inline ] pub fn pid21 ( & mut self ) -> _PID21W { _PID21W { w : self } } # [ doc = "Bit 22 - Peripheral Clock 22 Enable" ] # [ inline ] pub fn pid22 ( & mut self ) -> _PID22W { _PID22W { w : self } } # [ doc = "Bit 23 - Peripheral Clock 23 Enable" ] # [ inline ] pub fn pid23 ( & mut self ) -> _PID23W { _PID23W { w : self } } # [ doc = "Bit 24 - Peripheral Clock 24 Enable" ] # [ inline ] pub fn pid24 ( & mut self ) -> _PID24W { _PID24W { w : self } } # [ doc = "Bit 25 - Peripheral Clock 25 Enable" ] # [ inline ] pub fn pid25 ( & mut self ) -> _PID25W { _PID25W { w : self } } # [ doc = "Bit 26 - Peripheral Clock 26 Enable" ] # [ inline ] pub fn pid26 ( & mut self ) -> _PID26W { _PID26W { w : self } } # [ doc = "Bit 27 - Peripheral Clock 27 Enable" ] # [ inline ] pub fn pid27 ( & mut self ) -> _PID27W { _PID27W { w : self } } # [ doc = "Bit 28 - Peripheral Clock 28 Enable" ] # [ inline ] pub fn pid28 ( & mut self ) -> _PID28W { _PID28W { w : self } } # [ doc = "Bit 29 - Peripheral Clock 29 Enable" ] # [ inline ] pub fn pid29 ( & mut self ) -> _PID29W { _PID29W { w : self } } # [ doc = "Bit 30 - Peripheral Clock 30 Enable" ] # [ inline ] pub fn pid30 ( & mut self ) -> _PID30W { _PID30W { w : self } } # [ doc = "Bit 31 - Peripheral Clock 31 Enable" ] # [ inline ] pub fn pid31 ( & mut self ) -> _PID31W { _PID31W { w : self } } } } # [ doc = "Peripheral Clock Disable Register 0" ] pub struct PMC_PCDR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral Clock Disable Register 0" ] pub mod pmc_pcdr0 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_PCDR0 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _PID8W < 'a > { w : & 'a mut W , } impl < 'a > _PID8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID9W < 'a > { w : & 'a mut W , } impl < 'a > _PID9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID10W < 'a > { w : & 'a mut W , } impl < 'a > _PID10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID11W < 'a > { w : & 'a mut W , } impl < 'a > _PID11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID12W < 'a > { w : & 'a mut W , } impl < 'a > _PID12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID13W < 'a > { w : & 'a mut W , } impl < 'a > _PID13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID14W < 'a > { w : & 'a mut W , } impl < 'a > _PID14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID15W < 'a > { w : & 'a mut W , } impl < 'a > _PID15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID16W < 'a > { w : & 'a mut W , } impl < 'a > _PID16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID17W < 'a > { w : & 'a mut W , } impl < 'a > _PID17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID18W < 'a > { w : & 'a mut W , } impl < 'a > _PID18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID19W < 'a > { w : & 'a mut W , } impl < 'a > _PID19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID20W < 'a > { w : & 'a mut W , } impl < 'a > _PID20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID21W < 'a > { w : & 'a mut W , } impl < 'a > _PID21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID22W < 'a > { w : & 'a mut W , } impl < 'a > _PID22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID23W < 'a > { w : & 'a mut W , } impl < 'a > _PID23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID24W < 'a > { w : & 'a mut W , } impl < 'a > _PID24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID25W < 'a > { w : & 'a mut W , } impl < 'a > _PID25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID26W < 'a > { w : & 'a mut W , } impl < 'a > _PID26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID27W < 'a > { w : & 'a mut W , } impl < 'a > _PID27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID28W < 'a > { w : & 'a mut W , } impl < 'a > _PID28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID29W < 'a > { w : & 'a mut W , } impl < 'a > _PID29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID30W < 'a > { w : & 'a mut W , } impl < 'a > _PID30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID31W < 'a > { w : & 'a mut W , } impl < 'a > _PID31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 8 - Peripheral Clock 8 Disable" ] # [ inline ] pub fn pid8 ( & mut self ) -> _PID8W { _PID8W { w : self } } # [ doc = "Bit 9 - Peripheral Clock 9 Disable" ] # [ inline ] pub fn pid9 ( & mut self ) -> _PID9W { _PID9W { w : self } } # [ doc = "Bit 10 - Peripheral Clock 10 Disable" ] # [ inline ] pub fn pid10 ( & mut self ) -> _PID10W { _PID10W { w : self } } # [ doc = "Bit 11 - Peripheral Clock 11 Disable" ] # [ inline ] pub fn pid11 ( & mut self ) -> _PID11W { _PID11W { w : self } } # [ doc = "Bit 12 - Peripheral Clock 12 Disable" ] # [ inline ] pub fn pid12 ( & mut self ) -> _PID12W { _PID12W { w : self } } # [ doc = "Bit 13 - Peripheral Clock 13 Disable" ] # [ inline ] pub fn pid13 ( & mut self ) -> _PID13W { _PID13W { w : self } } # [ doc = "Bit 14 - Peripheral Clock 14 Disable" ] # [ inline ] pub fn pid14 ( & mut self ) -> _PID14W { _PID14W { w : self } } # [ doc = "Bit 15 - Peripheral Clock 15 Disable" ] # [ inline ] pub fn pid15 ( & mut self ) -> _PID15W { _PID15W { w : self } } # [ doc = "Bit 16 - Peripheral Clock 16 Disable" ] # [ inline ] pub fn pid16 ( & mut self ) -> _PID16W { _PID16W { w : self } } # [ doc = "Bit 17 - Peripheral Clock 17 Disable" ] # [ inline ] pub fn pid17 ( & mut self ) -> _PID17W { _PID17W { w : self } } # [ doc = "Bit 18 - Peripheral Clock 18 Disable" ] # [ inline ] pub fn pid18 ( & mut self ) -> _PID18W { _PID18W { w : self } } # [ doc = "Bit 19 - Peripheral Clock 19 Disable" ] # [ inline ] pub fn pid19 ( & mut self ) -> _PID19W { _PID19W { w : self } } # [ doc = "Bit 20 - Peripheral Clock 20 Disable" ] # [ inline ] pub fn pid20 ( & mut self ) -> _PID20W { _PID20W { w : self } } # [ doc = "Bit 21 - Peripheral Clock 21 Disable" ] # [ inline ] pub fn pid21 ( & mut self ) -> _PID21W { _PID21W { w : self } } # [ doc = "Bit 22 - Peripheral Clock 22 Disable" ] # [ inline ] pub fn pid22 ( & mut self ) -> _PID22W { _PID22W { w : self } } # [ doc = "Bit 23 - Peripheral Clock 23 Disable" ] # [ inline ] pub fn pid23 ( & mut self ) -> _PID23W { _PID23W { w : self } } # [ doc = "Bit 24 - Peripheral Clock 24 Disable" ] # [ inline ] pub fn pid24 ( & mut self ) -> _PID24W { _PID24W { w : self } } # [ doc = "Bit 25 - Peripheral Clock 25 Disable" ] # [ inline ] pub fn pid25 ( & mut self ) -> _PID25W { _PID25W { w : self } } # [ doc = "Bit 26 - Peripheral Clock 26 Disable" ] # [ inline ] pub fn pid26 ( & mut self ) -> _PID26W { _PID26W { w : self } } # [ doc = "Bit 27 - Peripheral Clock 27 Disable" ] # [ inline ] pub fn pid27 ( & mut self ) -> _PID27W { _PID27W { w : self } } # [ doc = "Bit 28 - Peripheral Clock 28 Disable" ] # [ inline ] pub fn pid28 ( & mut self ) -> _PID28W { _PID28W { w : self } } # [ doc = "Bit 29 - Peripheral Clock 29 Disable" ] # [ inline ] pub fn pid29 ( & mut self ) -> _PID29W { _PID29W { w : self } } # [ doc = "Bit 30 - Peripheral Clock 30 Disable" ] # [ inline ] pub fn pid30 ( & mut self ) -> _PID30W { _PID30W { w : self } } # [ doc = "Bit 31 - Peripheral Clock 31 Disable" ] # [ inline ] pub fn pid31 ( & mut self ) -> _PID31W { _PID31W { w : self } } } } # [ doc = "Peripheral Clock Status Register 0" ] pub struct PMC_PCSR0 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral Clock Status Register 0" ] pub mod pmc_pcsr0 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PMC_PCSR0 { # [ 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 PID8R { bits : bool , } impl PID8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID9R { bits : bool , } impl PID9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID10R { bits : bool , } impl PID10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID11R { bits : bool , } impl PID11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID12R { bits : bool , } impl PID12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID13R { bits : bool , } impl PID13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID14R { bits : bool , } impl PID14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID15R { bits : bool , } impl PID15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID16R { bits : bool , } impl PID16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID17R { bits : bool , } impl PID17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID18R { bits : bool , } impl PID18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID19R { bits : bool , } impl PID19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID20R { bits : bool , } impl PID20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID21R { bits : bool , } impl PID21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID22R { bits : bool , } impl PID22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID23R { bits : bool , } impl PID23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID24R { bits : bool , } impl PID24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID25R { bits : bool , } impl PID25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID26R { bits : bool , } impl PID26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID27R { bits : bool , } impl PID27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID28R { bits : bool , } impl PID28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID29R { bits : bool , } impl PID29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID30R { bits : bool , } impl PID30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID31R { bits : bool , } impl PID31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 8 - Peripheral Clock 8 Status" ] # [ inline ] pub fn pid8 ( & self ) -> PID8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID8R { bits } } # [ doc = "Bit 9 - Peripheral Clock 9 Status" ] # [ inline ] pub fn pid9 ( & self ) -> PID9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID9R { bits } } # [ doc = "Bit 10 - Peripheral Clock 10 Status" ] # [ inline ] pub fn pid10 ( & self ) -> PID10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID10R { bits } } # [ doc = "Bit 11 - Peripheral Clock 11 Status" ] # [ inline ] pub fn pid11 ( & self ) -> PID11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID11R { bits } } # [ doc = "Bit 12 - Peripheral Clock 12 Status" ] # [ inline ] pub fn pid12 ( & self ) -> PID12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID12R { bits } } # [ doc = "Bit 13 - Peripheral Clock 13 Status" ] # [ inline ] pub fn pid13 ( & self ) -> PID13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID13R { bits } } # [ doc = "Bit 14 - Peripheral Clock 14 Status" ] # [ inline ] pub fn pid14 ( & self ) -> PID14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID14R { bits } } # [ doc = "Bit 15 - Peripheral Clock 15 Status" ] # [ inline ] pub fn pid15 ( & self ) -> PID15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID15R { bits } } # [ doc = "Bit 16 - Peripheral Clock 16 Status" ] # [ inline ] pub fn pid16 ( & self ) -> PID16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID16R { bits } } # [ doc = "Bit 17 - Peripheral Clock 17 Status" ] # [ inline ] pub fn pid17 ( & self ) -> PID17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID17R { bits } } # [ doc = "Bit 18 - Peripheral Clock 18 Status" ] # [ inline ] pub fn pid18 ( & self ) -> PID18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID18R { bits } } # [ doc = "Bit 19 - Peripheral Clock 19 Status" ] # [ inline ] pub fn pid19 ( & self ) -> PID19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID19R { bits } } # [ doc = "Bit 20 - Peripheral Clock 20 Status" ] # [ inline ] pub fn pid20 ( & self ) -> PID20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID20R { bits } } # [ doc = "Bit 21 - Peripheral Clock 21 Status" ] # [ inline ] pub fn pid21 ( & self ) -> PID21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID21R { bits } } # [ doc = "Bit 22 - Peripheral Clock 22 Status" ] # [ inline ] pub fn pid22 ( & self ) -> PID22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID22R { bits } } # [ doc = "Bit 23 - Peripheral Clock 23 Status" ] # [ inline ] pub fn pid23 ( & self ) -> PID23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID23R { bits } } # [ doc = "Bit 24 - Peripheral Clock 24 Status" ] # [ inline ] pub fn pid24 ( & self ) -> PID24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID24R { bits } } # [ doc = "Bit 25 - Peripheral Clock 25 Status" ] # [ inline ] pub fn pid25 ( & self ) -> PID25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID25R { bits } } # [ doc = "Bit 26 - Peripheral Clock 26 Status" ] # [ inline ] pub fn pid26 ( & self ) -> PID26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID26R { bits } } # [ doc = "Bit 27 - Peripheral Clock 27 Status" ] # [ inline ] pub fn pid27 ( & self ) -> PID27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID27R { bits } } # [ doc = "Bit 28 - Peripheral Clock 28 Status" ] # [ inline ] pub fn pid28 ( & self ) -> PID28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID28R { bits } } # [ doc = "Bit 29 - Peripheral Clock 29 Status" ] # [ inline ] pub fn pid29 ( & self ) -> PID29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID29R { bits } } # [ doc = "Bit 30 - Peripheral Clock 30 Status" ] # [ inline ] pub fn pid30 ( & self ) -> PID30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID30R { bits } } # [ doc = "Bit 31 - Peripheral Clock 31 Status" ] # [ inline ] pub fn pid31 ( & self ) -> PID31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID31R { bits } } } } # [ doc = "UTMI Clock Register" ] pub struct CKGR_UCKR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "UTMI Clock Register" ] pub mod ckgr_uckr { # [ 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 :: CKGR_UCKR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 UPLLENR { bits : bool , } impl UPLLENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UPLLCOUNTR { bits : u8 , } impl UPLLCOUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _UPLLENW < 'a > { w : & 'a mut W , } impl < 'a > _UPLLENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UPLLCOUNTW < 'a > { w : & 'a mut W , } impl < 'a > _UPLLCOUNTW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 16 - UTMI PLL Enable" ] # [ inline ] pub fn upllen ( & self ) -> UPLLENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UPLLENR { bits } } # [ doc = "Bits 20:23 - UTMI PLL Start-up Time" ] # [ inline ] pub fn upllcount ( & self ) -> UPLLCOUNTR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; UPLLCOUNTR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x1020_0800 } } # [ 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 - UTMI PLL Enable" ] # [ inline ] pub fn upllen ( & mut self ) -> _UPLLENW { _UPLLENW { w : self } } # [ doc = "Bits 20:23 - UTMI PLL Start-up Time" ] # [ inline ] pub fn upllcount ( & mut self ) -> _UPLLCOUNTW { _UPLLCOUNTW { w : self } } } } # [ doc = "Main Oscillator Register" ] pub struct CKGR_MOR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Main Oscillator Register" ] pub mod ckgr_mor { # [ 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 :: CKGR_MOR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MOSCXTENR { bits : bool , } impl MOSCXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MOSCXTBYR { bits : bool , } impl MOSCXTBYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MOSCRCENR { bits : bool , } impl MOSCRCENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `MOSCRCF`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum MOSCRCFR { # [ doc = "The Fast RC Oscillator Frequency is at 4 MHz (default)" ] _4_MHZ , # [ doc = "The Fast RC Oscillator Frequency is at 8 MHz" ] _8_MHZ , # [ doc = "The Fast RC Oscillator Frequency is at 12 MHz" ] _12_MHZ , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl MOSCRCFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { MOSCRCFR :: _4_MHZ => 0 , MOSCRCFR :: _8_MHZ => 0x01 , MOSCRCFR :: _12_MHZ => 0x02 , MOSCRCFR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> MOSCRCFR { match value { 0 => MOSCRCFR :: _4_MHZ , 1 => MOSCRCFR :: _8_MHZ , 2 => MOSCRCFR :: _12_MHZ , i => MOSCRCFR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `_4_MHZ`" ] # [ inline ] pub fn is_4_mhz ( & self ) -> bool { * self == MOSCRCFR :: _4_MHZ } # [ doc = "Checks if the value of the field is `_8_MHZ`" ] # [ inline ] pub fn is_8_mhz ( & self ) -> bool { * self == MOSCRCFR :: _8_MHZ } # [ doc = "Checks if the value of the field is `_12_MHZ`" ] # [ inline ] pub fn is_12_mhz ( & self ) -> bool { * self == MOSCRCFR :: _12_MHZ } } # [ doc = r" Value of the field" ] pub struct MOSCXTSTR { bits : u8 , } impl MOSCXTSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `KEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum KEYR { # [ doc = "Writing any other value in this field aborts the write operation.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl KEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { KEYR :: PASSWD => 0x37 , KEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> KEYR { match value { 55 => KEYR :: PASSWD , i => KEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == KEYR :: PASSWD } } # [ doc = r" Value of the field" ] pub struct MOSCSELR { bits : bool , } impl MOSCSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFDENR { bits : bool , } impl CFDENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MOSCXTENW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MOSCXTBYW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCXTBYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MOSCRCENW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCRCENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `MOSCRCF`" ] pub enum MOSCRCFW { # [ doc = "The Fast RC Oscillator Frequency is at 4 MHz (default)" ] _4_MHZ , # [ doc = "The Fast RC Oscillator Frequency is at 8 MHz" ] _8_MHZ , # [ doc = "The Fast RC Oscillator Frequency is at 12 MHz" ] _12_MHZ } impl MOSCRCFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { MOSCRCFW :: _4_MHZ => 0 , MOSCRCFW :: _8_MHZ => 1 , MOSCRCFW :: _12_MHZ => 2 } } } # [ doc = r" Proxy" ] pub struct _MOSCRCFW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCRCFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : MOSCRCFW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The Fast RC Oscillator Frequency is at 4 MHz (default)" ] # [ inline ] pub fn _4_mhz ( self ) -> & 'a mut W { self . variant ( MOSCRCFW :: _4_MHZ ) } # [ doc = "The Fast RC Oscillator Frequency is at 8 MHz" ] # [ inline ] pub fn _8_mhz ( self ) -> & 'a mut W { self . variant ( MOSCRCFW :: _8_MHZ ) } # [ doc = "The Fast RC Oscillator Frequency is at 12 MHz" ] # [ inline ] pub fn _12_mhz ( self ) -> & 'a mut W { self . variant ( MOSCRCFW :: _12_MHZ ) } # [ 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 _MOSCXTSTW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCXTSTW < '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 = "Values that can be written to the field `KEY`" ] pub enum KEYW { # [ doc = "Writing any other value in this field aborts the write operation.Always reads as 0." ] PASSWD } impl KEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { KEYW :: PASSWD => 55 } } } # [ doc = r" Proxy" ] pub struct _KEYW < 'a > { w : & 'a mut W , } impl < 'a > _KEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : KEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( KEYW :: PASSWD ) } # [ 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 _MOSCSELW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCSELW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CFDENW < 'a > { w : & 'a mut W , } impl < 'a > _CFDENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Main Crystal Oscillator Enable" ] # [ inline ] pub fn moscxten ( & self ) -> MOSCXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCXTENR { bits } } # [ doc = "Bit 1 - Main Crystal Oscillator Bypass" ] # [ inline ] pub fn moscxtby ( & self ) -> MOSCXTBYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCXTBYR { bits } } # [ doc = "Bit 3 - Main On-Chip RC Oscillator Enable" ] # [ inline ] pub fn moscrcen ( & self ) -> MOSCRCENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCRCENR { bits } } # [ doc = "Bits 4:6 - Main On-Chip RC Oscillator Frequency Selection" ] # [ inline ] pub fn moscrcf ( & self ) -> MOSCRCFR { MOSCRCFR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 8:15 - Main Crystal Oscillator Start-up Time" ] # [ inline ] pub fn moscxtst ( & self ) -> MOSCXTSTR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MOSCXTSTR { bits } } # [ doc = "Bits 16:23 - Write Access Password" ] # [ inline ] pub fn key ( & self ) -> KEYR { KEYR :: _from ( { const MASK : u8 = 0xff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 24 - Main Oscillator Selection" ] # [ inline ] pub fn moscsel ( & self ) -> MOSCSELR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCSELR { bits } } # [ doc = "Bit 25 - Clock Failure Detector Enable" ] # [ inline ] pub fn cfden ( & self ) -> CFDENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFDENR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x08 } } # [ 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 - Main Crystal Oscillator Enable" ] # [ inline ] pub fn moscxten ( & mut self ) -> _MOSCXTENW { _MOSCXTENW { w : self } } # [ doc = "Bit 1 - Main Crystal Oscillator Bypass" ] # [ inline ] pub fn moscxtby ( & mut self ) -> _MOSCXTBYW { _MOSCXTBYW { w : self } } # [ doc = "Bit 3 - Main On-Chip RC Oscillator Enable" ] # [ inline ] pub fn moscrcen ( & mut self ) -> _MOSCRCENW { _MOSCRCENW { w : self } } # [ doc = "Bits 4:6 - Main On-Chip RC Oscillator Frequency Selection" ] # [ inline ] pub fn moscrcf ( & mut self ) -> _MOSCRCFW { _MOSCRCFW { w : self } } # [ doc = "Bits 8:15 - Main Crystal Oscillator Start-up Time" ] # [ inline ] pub fn moscxtst ( & mut self ) -> _MOSCXTSTW { _MOSCXTSTW { w : self } } # [ doc = "Bits 16:23 - Write Access Password" ] # [ inline ] pub fn key ( & mut self ) -> _KEYW { _KEYW { w : self } } # [ doc = "Bit 24 - Main Oscillator Selection" ] # [ inline ] pub fn moscsel ( & mut self ) -> _MOSCSELW { _MOSCSELW { w : self } } # [ doc = "Bit 25 - Clock Failure Detector Enable" ] # [ inline ] pub fn cfden ( & mut self ) -> _CFDENW { _CFDENW { w : self } } } } # [ doc = "Main Clock Frequency Register" ] pub struct CKGR_MCFR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Main Clock Frequency Register" ] pub mod ckgr_mcfr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CKGR_MCFR { # [ 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 MAINFR { bits : u16 , } impl MAINFR { # [ 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 MAINFRDYR { bits : bool , } impl MAINFRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:15 - Main Clock Frequency" ] # [ inline ] pub fn mainf ( & self ) -> MAINFR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MAINFR { bits } } # [ doc = "Bit 16 - Main Clock Ready" ] # [ inline ] pub fn mainfrdy ( & self ) -> MAINFRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MAINFRDYR { bits } } } } # [ doc = "PLLA Register" ] pub struct CKGR_PLLAR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PLLA Register" ] pub mod ckgr_pllar { # [ 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 :: CKGR_PLLAR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DIVAR { bits : u8 , } impl DIVAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct PLLACOUNTR { bits : u8 , } impl PLLACOUNTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MULAR { bits : u16 , } impl MULAR { # [ 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 ONER { bits : bool , } impl ONER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _DIVAW < 'a > { w : & 'a mut W , } impl < 'a > _DIVAW < '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 _PLLACOUNTW < 'a > { w : & 'a mut W , } impl < 'a > _PLLACOUNTW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _MULAW < 'a > { w : & 'a mut W , } impl < 'a > _MULAW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x07ff ; 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 _ONEW < 'a > { w : & 'a mut W , } impl < 'a > _ONEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:7 - Divider" ] # [ inline ] pub fn diva ( & self ) -> DIVAR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DIVAR { bits } } # [ doc = "Bits 8:13 - PLLA Counter" ] # [ inline ] pub fn pllacount ( & self ) -> PLLACOUNTR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PLLACOUNTR { bits } } # [ doc = "Bits 16:26 - PLLA Multiplier" ] # [ inline ] pub fn mula ( & self ) -> MULAR { let bits = { const MASK : u16 = 0x07ff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; MULAR { bits } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & self ) -> ONER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ONER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x3f00 } } # [ 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 - Divider" ] # [ inline ] pub fn diva ( & mut self ) -> _DIVAW { _DIVAW { w : self } } # [ doc = "Bits 8:13 - PLLA Counter" ] # [ inline ] pub fn pllacount ( & mut self ) -> _PLLACOUNTW { _PLLACOUNTW { w : self } } # [ doc = "Bits 16:26 - PLLA Multiplier" ] # [ inline ] pub fn mula ( & mut self ) -> _MULAW { _MULAW { w : self } } # [ doc = "Bit 29 - Must Be Set to 1" ] # [ inline ] pub fn one ( & mut self ) -> _ONEW { _ONEW { w : self } } } } # [ doc = "Master Clock Register" ] pub struct PMC_MCKR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Master Clock Register" ] pub mod pmc_mckr { # [ 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 :: PMC_MCKR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `CSS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CSSR { # [ doc = "Slow Clock is selected" ] SLOW_CLK , # [ doc = "Main Clock is selected" ] MAIN_CLK , # [ doc = "PLLA Clock is selected" ] PLLA_CLK , # [ doc = "UPLL Clock is selected" ] UPLL_CLK } impl CSSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CSSR :: SLOW_CLK => 0 , CSSR :: MAIN_CLK => 0x01 , CSSR :: PLLA_CLK => 0x02 , CSSR :: UPLL_CLK => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CSSR { match value { 0 => CSSR :: SLOW_CLK , 1 => CSSR :: MAIN_CLK , 2 => CSSR :: PLLA_CLK , 3 => CSSR :: UPLL_CLK , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `SLOW_CLK`" ] # [ inline ] pub fn is_slow_clk ( & self ) -> bool { * self == CSSR :: SLOW_CLK } # [ doc = "Checks if the value of the field is `MAIN_CLK`" ] # [ inline ] pub fn is_main_clk ( & self ) -> bool { * self == CSSR :: MAIN_CLK } # [ doc = "Checks if the value of the field is `PLLA_CLK`" ] # [ inline ] pub fn is_plla_clk ( & self ) -> bool { * self == CSSR :: PLLA_CLK } # [ doc = "Checks if the value of the field is `UPLL_CLK`" ] # [ inline ] pub fn is_upll_clk ( & self ) -> bool { * self == CSSR :: UPLL_CLK } } # [ doc = "Possible values of the field `PRES`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PRESR { # [ doc = "Selected clock" ] CLK_1 , # [ doc = "Selected clock divided by 2" ] CLK_2 , # [ doc = "Selected clock divided by 4" ] CLK_4 , # [ doc = "Selected clock divided by 8" ] CLK_8 , # [ doc = "Selected clock divided by 16" ] CLK_16 , # [ doc = "Selected clock divided by 32" ] CLK_32 , # [ doc = "Selected clock divided by 64" ] CLK_64 , # [ doc = "Selected clock divided by 3" ] CLK_3 } impl PRESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PRESR :: CLK_1 => 0 , PRESR :: CLK_2 => 0x01 , PRESR :: CLK_4 => 0x02 , PRESR :: CLK_8 => 0x03 , PRESR :: CLK_16 => 0x04 , PRESR :: CLK_32 => 0x05 , PRESR :: CLK_64 => 0x06 , PRESR :: CLK_3 => 0x07 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PRESR { match value { 0 => PRESR :: CLK_1 , 1 => PRESR :: CLK_2 , 2 => PRESR :: CLK_4 , 3 => PRESR :: CLK_8 , 4 => PRESR :: CLK_16 , 5 => PRESR :: CLK_32 , 6 => PRESR :: CLK_64 , 7 => PRESR :: CLK_3 , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `CLK_1`" ] # [ inline ] pub fn is_clk_1 ( & self ) -> bool { * self == PRESR :: CLK_1 } # [ doc = "Checks if the value of the field is `CLK_2`" ] # [ inline ] pub fn is_clk_2 ( & self ) -> bool { * self == PRESR :: CLK_2 } # [ doc = "Checks if the value of the field is `CLK_4`" ] # [ inline ] pub fn is_clk_4 ( & self ) -> bool { * self == PRESR :: CLK_4 } # [ doc = "Checks if the value of the field is `CLK_8`" ] # [ inline ] pub fn is_clk_8 ( & self ) -> bool { * self == PRESR :: CLK_8 } # [ doc = "Checks if the value of the field is `CLK_16`" ] # [ inline ] pub fn is_clk_16 ( & self ) -> bool { * self == PRESR :: CLK_16 } # [ doc = "Checks if the value of the field is `CLK_32`" ] # [ inline ] pub fn is_clk_32 ( & self ) -> bool { * self == PRESR :: CLK_32 } # [ doc = "Checks if the value of the field is `CLK_64`" ] # [ inline ] pub fn is_clk_64 ( & self ) -> bool { * self == PRESR :: CLK_64 } # [ doc = "Checks if the value of the field is `CLK_3`" ] # [ inline ] pub fn is_clk_3 ( & self ) -> bool { * self == PRESR :: CLK_3 } } # [ doc = r" Value of the field" ] pub struct PLLADIV2R { bits : bool , } impl PLLADIV2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UPLLDIV2R { bits : bool , } impl UPLLDIV2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Values that can be written to the field `CSS`" ] pub enum CSSW { # [ doc = "Slow Clock is selected" ] SLOW_CLK , # [ doc = "Main Clock is selected" ] MAIN_CLK , # [ doc = "PLLA Clock is selected" ] PLLA_CLK , # [ doc = "UPLL Clock is selected" ] UPLL_CLK } impl CSSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CSSW :: SLOW_CLK => 0 , CSSW :: MAIN_CLK => 1 , CSSW :: PLLA_CLK => 2 , CSSW :: UPLL_CLK => 3 } } } # [ doc = r" Proxy" ] pub struct _CSSW < 'a > { w : & 'a mut W , } impl < 'a > _CSSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CSSW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Slow Clock is selected" ] # [ inline ] pub fn slow_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: SLOW_CLK ) } # [ doc = "Main Clock is selected" ] # [ inline ] pub fn main_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: MAIN_CLK ) } # [ doc = "PLLA Clock is selected" ] # [ inline ] pub fn plla_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: PLLA_CLK ) } # [ doc = "UPLL Clock is selected" ] # [ inline ] pub fn upll_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: UPLL_CLK ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `PRES`" ] pub enum PRESW { # [ doc = "Selected clock" ] CLK_1 , # [ doc = "Selected clock divided by 2" ] CLK_2 , # [ doc = "Selected clock divided by 4" ] CLK_4 , # [ doc = "Selected clock divided by 8" ] CLK_8 , # [ doc = "Selected clock divided by 16" ] CLK_16 , # [ doc = "Selected clock divided by 32" ] CLK_32 , # [ doc = "Selected clock divided by 64" ] CLK_64 , # [ doc = "Selected clock divided by 3" ] CLK_3 } impl PRESW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PRESW :: CLK_1 => 0 , PRESW :: CLK_2 => 1 , PRESW :: CLK_4 => 2 , PRESW :: CLK_8 => 3 , PRESW :: CLK_16 => 4 , PRESW :: CLK_32 => 5 , PRESW :: CLK_64 => 6 , PRESW :: CLK_3 => 7 } } } # [ doc = r" Proxy" ] pub struct _PRESW < 'a > { w : & 'a mut W , } impl < 'a > _PRESW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PRESW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Selected clock" ] # [ inline ] pub fn clk_1 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_1 ) } # [ doc = "Selected clock divided by 2" ] # [ inline ] pub fn clk_2 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_2 ) } # [ doc = "Selected clock divided by 4" ] # [ inline ] pub fn clk_4 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_4 ) } # [ doc = "Selected clock divided by 8" ] # [ inline ] pub fn clk_8 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_8 ) } # [ doc = "Selected clock divided by 16" ] # [ inline ] pub fn clk_16 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_16 ) } # [ doc = "Selected clock divided by 32" ] # [ inline ] pub fn clk_32 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_32 ) } # [ doc = "Selected clock divided by 64" ] # [ inline ] pub fn clk_64 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_64 ) } # [ doc = "Selected clock divided by 3" ] # [ inline ] pub fn clk_3 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_3 ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 _PLLADIV2W < 'a > { w : & 'a mut W , } impl < 'a > _PLLADIV2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UPLLDIV2W < 'a > { w : & 'a mut W , } impl < 'a > _UPLLDIV2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:1 - Master Clock Source Selection" ] # [ inline ] pub fn css ( & self ) -> CSSR { CSSR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:6 - Processor Clock Prescaler" ] # [ inline ] pub fn pres ( & self ) -> PRESR { PRESR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - PLLA Divisor by 2" ] # [ inline ] pub fn plladiv2 ( & self ) -> PLLADIV2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PLLADIV2R { bits } } # [ doc = "Bit 13" ] # [ inline ] pub fn uplldiv2 ( & self ) -> UPLLDIV2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UPLLDIV2R { 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 = "Bits 0:1 - Master Clock Source Selection" ] # [ inline ] pub fn css ( & mut self ) -> _CSSW { _CSSW { w : self } } # [ doc = "Bits 4:6 - Processor Clock Prescaler" ] # [ inline ] pub fn pres ( & mut self ) -> _PRESW { _PRESW { w : self } } # [ doc = "Bit 12 - PLLA Divisor by 2" ] # [ inline ] pub fn plladiv2 ( & mut self ) -> _PLLADIV2W { _PLLADIV2W { w : self } } # [ doc = "Bit 13" ] # [ inline ] pub fn uplldiv2 ( & mut self ) -> _UPLLDIV2W { _UPLLDIV2W { w : self } } } } # [ doc = "USB Clock Register" ] pub struct PMC_USB { register : :: vcell :: VolatileCell < u32 > } # [ doc = "USB Clock Register" ] pub mod pmc_usb { # [ 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 :: PMC_USB { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 USBSR { bits : bool , } impl USBSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct USBDIVR { bits : u8 , } impl USBDIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _USBSW < 'a > { w : & 'a mut W , } impl < 'a > _USBSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _USBDIVW < 'a > { w : & 'a mut W , } impl < 'a > _USBDIVW < '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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - USB Input Clock Selection" ] # [ inline ] pub fn usbs ( & self ) -> USBSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; USBSR { bits } } # [ doc = "Bits 8:11 - Divider for USB Clock." ] # [ inline ] pub fn usbdiv ( & self ) -> USBDIVR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; USBDIVR { 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 - USB Input Clock Selection" ] # [ inline ] pub fn usbs ( & mut self ) -> _USBSW { _USBSW { w : self } } # [ doc = "Bits 8:11 - Divider for USB Clock." ] # [ inline ] pub fn usbdiv ( & mut self ) -> _USBDIVW { _USBDIVW { w : self } } } } # [ doc = "Programmable Clock 0 Register" ] pub struct PMC_PCK { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Programmable Clock 0 Register" ] pub mod pmc_pck { # [ 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 :: PMC_PCK { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 = "Possible values of the field `CSS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CSSR { # [ doc = "Slow Clock is selected" ] SLOW_CLK , # [ doc = "Main Clock is selected" ] MAIN_CLK , # [ doc = "PLLA Clock is selected" ] PLLA_CLK , # [ doc = "UPLL Clock is selected" ] UPLL_CLK , # [ doc = "Master Clock is selected" ] MCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CSSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CSSR :: SLOW_CLK => 0 , CSSR :: MAIN_CLK => 0x01 , CSSR :: PLLA_CLK => 0x02 , CSSR :: UPLL_CLK => 0x03 , CSSR :: MCK => 0x04 , CSSR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CSSR { match value { 0 => CSSR :: SLOW_CLK , 1 => CSSR :: MAIN_CLK , 2 => CSSR :: PLLA_CLK , 3 => CSSR :: UPLL_CLK , 4 => CSSR :: MCK , i => CSSR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SLOW_CLK`" ] # [ inline ] pub fn is_slow_clk ( & self ) -> bool { * self == CSSR :: SLOW_CLK } # [ doc = "Checks if the value of the field is `MAIN_CLK`" ] # [ inline ] pub fn is_main_clk ( & self ) -> bool { * self == CSSR :: MAIN_CLK } # [ doc = "Checks if the value of the field is `PLLA_CLK`" ] # [ inline ] pub fn is_plla_clk ( & self ) -> bool { * self == CSSR :: PLLA_CLK } # [ doc = "Checks if the value of the field is `UPLL_CLK`" ] # [ inline ] pub fn is_upll_clk ( & self ) -> bool { * self == CSSR :: UPLL_CLK } # [ doc = "Checks if the value of the field is `MCK`" ] # [ inline ] pub fn is_mck ( & self ) -> bool { * self == CSSR :: MCK } } # [ doc = "Possible values of the field `PRES`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PRESR { # [ doc = "Selected clock" ] CLK_1 , # [ doc = "Selected clock divided by 2" ] CLK_2 , # [ doc = "Selected clock divided by 4" ] CLK_4 , # [ doc = "Selected clock divided by 8" ] CLK_8 , # [ doc = "Selected clock divided by 16" ] CLK_16 , # [ doc = "Selected clock divided by 32" ] CLK_32 , # [ doc = "Selected clock divided by 64" ] CLK_64 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PRESR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PRESR :: CLK_1 => 0 , PRESR :: CLK_2 => 0x01 , PRESR :: CLK_4 => 0x02 , PRESR :: CLK_8 => 0x03 , PRESR :: CLK_16 => 0x04 , PRESR :: CLK_32 => 0x05 , PRESR :: CLK_64 => 0x06 , PRESR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PRESR { match value { 0 => PRESR :: CLK_1 , 1 => PRESR :: CLK_2 , 2 => PRESR :: CLK_4 , 3 => PRESR :: CLK_8 , 4 => PRESR :: CLK_16 , 5 => PRESR :: CLK_32 , 6 => PRESR :: CLK_64 , i => PRESR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `CLK_1`" ] # [ inline ] pub fn is_clk_1 ( & self ) -> bool { * self == PRESR :: CLK_1 } # [ doc = "Checks if the value of the field is `CLK_2`" ] # [ inline ] pub fn is_clk_2 ( & self ) -> bool { * self == PRESR :: CLK_2 } # [ doc = "Checks if the value of the field is `CLK_4`" ] # [ inline ] pub fn is_clk_4 ( & self ) -> bool { * self == PRESR :: CLK_4 } # [ doc = "Checks if the value of the field is `CLK_8`" ] # [ inline ] pub fn is_clk_8 ( & self ) -> bool { * self == PRESR :: CLK_8 } # [ doc = "Checks if the value of the field is `CLK_16`" ] # [ inline ] pub fn is_clk_16 ( & self ) -> bool { * self == PRESR :: CLK_16 } # [ doc = "Checks if the value of the field is `CLK_32`" ] # [ inline ] pub fn is_clk_32 ( & self ) -> bool { * self == PRESR :: CLK_32 } # [ doc = "Checks if the value of the field is `CLK_64`" ] # [ inline ] pub fn is_clk_64 ( & self ) -> bool { * self == PRESR :: CLK_64 } } # [ doc = "Values that can be written to the field `CSS`" ] pub enum CSSW { # [ doc = "Slow Clock is selected" ] SLOW_CLK , # [ doc = "Main Clock is selected" ] MAIN_CLK , # [ doc = "PLLA Clock is selected" ] PLLA_CLK , # [ doc = "UPLL Clock is selected" ] UPLL_CLK , # [ doc = "Master Clock is selected" ] MCK } impl CSSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CSSW :: SLOW_CLK => 0 , CSSW :: MAIN_CLK => 1 , CSSW :: PLLA_CLK => 2 , CSSW :: UPLL_CLK => 3 , CSSW :: MCK => 4 } } } # [ doc = r" Proxy" ] pub struct _CSSW < 'a > { w : & 'a mut W , } impl < 'a > _CSSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CSSW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Slow Clock is selected" ] # [ inline ] pub fn slow_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: SLOW_CLK ) } # [ doc = "Main Clock is selected" ] # [ inline ] pub fn main_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: MAIN_CLK ) } # [ doc = "PLLA Clock is selected" ] # [ inline ] pub fn plla_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: PLLA_CLK ) } # [ doc = "UPLL Clock is selected" ] # [ inline ] pub fn upll_clk ( self ) -> & 'a mut W { self . variant ( CSSW :: UPLL_CLK ) } # [ doc = "Master Clock is selected" ] # [ inline ] pub fn mck ( self ) -> & 'a mut W { self . variant ( CSSW :: MCK ) } # [ 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 = "Values that can be written to the field `PRES`" ] pub enum PRESW { # [ doc = "Selected clock" ] CLK_1 , # [ doc = "Selected clock divided by 2" ] CLK_2 , # [ doc = "Selected clock divided by 4" ] CLK_4 , # [ doc = "Selected clock divided by 8" ] CLK_8 , # [ doc = "Selected clock divided by 16" ] CLK_16 , # [ doc = "Selected clock divided by 32" ] CLK_32 , # [ doc = "Selected clock divided by 64" ] CLK_64 } impl PRESW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PRESW :: CLK_1 => 0 , PRESW :: CLK_2 => 1 , PRESW :: CLK_4 => 2 , PRESW :: CLK_8 => 3 , PRESW :: CLK_16 => 4 , PRESW :: CLK_32 => 5 , PRESW :: CLK_64 => 6 } } } # [ doc = r" Proxy" ] pub struct _PRESW < 'a > { w : & 'a mut W , } impl < 'a > _PRESW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PRESW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Selected clock" ] # [ inline ] pub fn clk_1 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_1 ) } # [ doc = "Selected clock divided by 2" ] # [ inline ] pub fn clk_2 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_2 ) } # [ doc = "Selected clock divided by 4" ] # [ inline ] pub fn clk_4 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_4 ) } # [ doc = "Selected clock divided by 8" ] # [ inline ] pub fn clk_8 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_8 ) } # [ doc = "Selected clock divided by 16" ] # [ inline ] pub fn clk_16 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_16 ) } # [ doc = "Selected clock divided by 32" ] # [ inline ] pub fn clk_32 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_32 ) } # [ doc = "Selected clock divided by 64" ] # [ inline ] pub fn clk_64 ( self ) -> & 'a mut W { self . variant ( PRESW :: CLK_64 ) } # [ 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:2 - Master Clock Source Selection" ] # [ inline ] pub fn css ( & self ) -> CSSR { CSSR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 4:6 - Programmable Clock Prescaler" ] # [ inline ] pub fn pres ( & self ) -> PRESR { PRESR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = "Bits 0:2 - Master Clock Source Selection" ] # [ inline ] pub fn css ( & mut self ) -> _CSSW { _CSSW { w : self } } # [ doc = "Bits 4:6 - Programmable Clock Prescaler" ] # [ inline ] pub fn pres ( & mut self ) -> _PRESW { _PRESW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct PMC_IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod pmc_ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MOSCXTSW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCXTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOCKAW < 'a > { w : & 'a mut W , } impl < 'a > _LOCKAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MCKRDYW < 'a > { w : & 'a mut W , } impl < 'a > _MCKRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOCKUW < 'a > { w : & 'a mut W , } impl < 'a > _LOCKUW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCKRDY0W < 'a > { w : & 'a mut W , } impl < 'a > _PCKRDY0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCKRDY1W < 'a > { w : & 'a mut W , } impl < 'a > _PCKRDY1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCKRDY2W < 'a > { w : & 'a mut W , } impl < 'a > _PCKRDY2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MOSCSELSW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCSELSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MOSCRCSW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCRCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CFDEVW < 'a > { w : & 'a mut W , } impl < 'a > _CFDEVW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Main Crystal Oscillator Status Interrupt Enable" ] # [ inline ] pub fn moscxts ( & mut self ) -> _MOSCXTSW { _MOSCXTSW { w : self } } # [ doc = "Bit 1 - PLLA Lock Interrupt Enable" ] # [ inline ] pub fn locka ( & mut self ) -> _LOCKAW { _LOCKAW { w : self } } # [ doc = "Bit 3 - Master Clock Ready Interrupt Enable" ] # [ inline ] pub fn mckrdy ( & mut self ) -> _MCKRDYW { _MCKRDYW { w : self } } # [ doc = "Bit 6 - UTMI PLL Lock Interrupt Enable" ] # [ inline ] pub fn locku ( & mut self ) -> _LOCKUW { _LOCKUW { w : self } } # [ doc = "Bit 8 - Programmable Clock Ready 0 Interrupt Enable" ] # [ inline ] pub fn pckrdy0 ( & mut self ) -> _PCKRDY0W { _PCKRDY0W { w : self } } # [ doc = "Bit 9 - Programmable Clock Ready 1 Interrupt Enable" ] # [ inline ] pub fn pckrdy1 ( & mut self ) -> _PCKRDY1W { _PCKRDY1W { w : self } } # [ doc = "Bit 10 - Programmable Clock Ready 2 Interrupt Enable" ] # [ inline ] pub fn pckrdy2 ( & mut self ) -> _PCKRDY2W { _PCKRDY2W { w : self } } # [ doc = "Bit 16 - Main Oscillator Selection Status Interrupt Enable" ] # [ inline ] pub fn moscsels ( & mut self ) -> _MOSCSELSW { _MOSCSELSW { w : self } } # [ doc = "Bit 17 - Main On-Chip RC Status Interrupt Enable" ] # [ inline ] pub fn moscrcs ( & mut self ) -> _MOSCRCSW { _MOSCRCSW { w : self } } # [ doc = "Bit 18 - Clock Failure Detector Event Interrupt Enable" ] # [ inline ] pub fn cfdev ( & mut self ) -> _CFDEVW { _CFDEVW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct PMC_IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod pmc_idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _MOSCXTSW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCXTSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOCKAW < 'a > { w : & 'a mut W , } impl < 'a > _LOCKAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MCKRDYW < 'a > { w : & 'a mut W , } impl < 'a > _MCKRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LOCKUW < 'a > { w : & 'a mut W , } impl < 'a > _LOCKUW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCKRDY0W < 'a > { w : & 'a mut W , } impl < 'a > _PCKRDY0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCKRDY1W < 'a > { w : & 'a mut W , } impl < 'a > _PCKRDY1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PCKRDY2W < 'a > { w : & 'a mut W , } impl < 'a > _PCKRDY2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MOSCSELSW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCSELSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MOSCRCSW < 'a > { w : & 'a mut W , } impl < 'a > _MOSCRCSW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CFDEVW < 'a > { w : & 'a mut W , } impl < 'a > _CFDEVW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Main Crystal Oscillator Status Interrupt Disable" ] # [ inline ] pub fn moscxts ( & mut self ) -> _MOSCXTSW { _MOSCXTSW { w : self } } # [ doc = "Bit 1 - PLLA Lock Interrupt Disable" ] # [ inline ] pub fn locka ( & mut self ) -> _LOCKAW { _LOCKAW { w : self } } # [ doc = "Bit 3 - Master Clock Ready Interrupt Disable" ] # [ inline ] pub fn mckrdy ( & mut self ) -> _MCKRDYW { _MCKRDYW { w : self } } # [ doc = "Bit 6 - UTMI PLL Lock Interrupt Disable" ] # [ inline ] pub fn locku ( & mut self ) -> _LOCKUW { _LOCKUW { w : self } } # [ doc = "Bit 8 - Programmable Clock Ready 0 Interrupt Disable" ] # [ inline ] pub fn pckrdy0 ( & mut self ) -> _PCKRDY0W { _PCKRDY0W { w : self } } # [ doc = "Bit 9 - Programmable Clock Ready 1 Interrupt Disable" ] # [ inline ] pub fn pckrdy1 ( & mut self ) -> _PCKRDY1W { _PCKRDY1W { w : self } } # [ doc = "Bit 10 - Programmable Clock Ready 2 Interrupt Disable" ] # [ inline ] pub fn pckrdy2 ( & mut self ) -> _PCKRDY2W { _PCKRDY2W { w : self } } # [ doc = "Bit 16 - Main Oscillator Selection Status Interrupt Disable" ] # [ inline ] pub fn moscsels ( & mut self ) -> _MOSCSELSW { _MOSCSELSW { w : self } } # [ doc = "Bit 17 - Main On-Chip RC Status Interrupt Disable" ] # [ inline ] pub fn moscrcs ( & mut self ) -> _MOSCRCSW { _MOSCRCSW { w : self } } # [ doc = "Bit 18 - Clock Failure Detector Event Interrupt Disable" ] # [ inline ] pub fn cfdev ( & mut self ) -> _CFDEVW { _CFDEVW { w : self } } } } # [ doc = "Status Register" ] pub struct PMC_SR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Register" ] pub mod pmc_sr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PMC_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 MOSCXTSR { bits : bool , } impl MOSCXTSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOCKAR { bits : bool , } impl LOCKAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MCKRDYR { bits : bool , } impl MCKRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOCKUR { bits : bool , } impl LOCKUR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OSCSELSR { bits : bool , } impl OSCSELSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCKRDY0R { bits : bool , } impl PCKRDY0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCKRDY1R { bits : bool , } impl PCKRDY1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCKRDY2R { bits : bool , } impl PCKRDY2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MOSCSELSR { bits : bool , } impl MOSCSELSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MOSCRCSR { bits : bool , } impl MOSCRCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFDEVR { bits : bool , } impl CFDEVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFDSR { bits : bool , } impl CFDSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FOSR { bits : bool , } impl FOSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Main XTAL Oscillator Status" ] # [ inline ] pub fn moscxts ( & self ) -> MOSCXTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCXTSR { bits } } # [ doc = "Bit 1 - PLLA Lock Status" ] # [ inline ] pub fn locka ( & self ) -> LOCKAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOCKAR { bits } } # [ doc = "Bit 3 - Master Clock Status" ] # [ inline ] pub fn mckrdy ( & self ) -> MCKRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MCKRDYR { bits } } # [ doc = "Bit 6 - UTMI PLL Lock Status" ] # [ inline ] pub fn locku ( & self ) -> LOCKUR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOCKUR { bits } } # [ doc = "Bit 7 - Slow Clock Oscillator Selection" ] # [ inline ] pub fn oscsels ( & self ) -> OSCSELSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OSCSELSR { bits } } # [ doc = "Bit 8 - Programmable Clock Ready Status" ] # [ inline ] pub fn pckrdy0 ( & self ) -> PCKRDY0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCKRDY0R { bits } } # [ doc = "Bit 9 - Programmable Clock Ready Status" ] # [ inline ] pub fn pckrdy1 ( & self ) -> PCKRDY1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCKRDY1R { bits } } # [ doc = "Bit 10 - Programmable Clock Ready Status" ] # [ inline ] pub fn pckrdy2 ( & self ) -> PCKRDY2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCKRDY2R { bits } } # [ doc = "Bit 16 - Main Oscillator Selection Status" ] # [ inline ] pub fn moscsels ( & self ) -> MOSCSELSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCSELSR { bits } } # [ doc = "Bit 17 - Main On-Chip RC Oscillator Status" ] # [ inline ] pub fn moscrcs ( & self ) -> MOSCRCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCRCSR { bits } } # [ doc = "Bit 18 - Clock Failure Detector Event" ] # [ inline ] pub fn cfdev ( & self ) -> CFDEVR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFDEVR { bits } } # [ doc = "Bit 19 - Clock Failure Detector Status" ] # [ inline ] pub fn cfds ( & self ) -> CFDSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFDSR { bits } } # [ doc = "Bit 20 - Clock Failure Detector Fault Output Status" ] # [ inline ] pub fn fos ( & self ) -> FOSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FOSR { bits } } } } # [ doc = "Interrupt Mask Register" ] pub struct PMC_IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod pmc_imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PMC_IMR { # [ 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 MOSCXTSR { bits : bool , } impl MOSCXTSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOCKAR { bits : bool , } impl LOCKAR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MCKRDYR { bits : bool , } impl MCKRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LOCKUR { bits : bool , } impl LOCKUR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCKRDY0R { bits : bool , } impl PCKRDY0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCKRDY1R { bits : bool , } impl PCKRDY1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PCKRDY2R { bits : bool , } impl PCKRDY2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MOSCSELSR { bits : bool , } impl MOSCSELSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MOSCRCSR { bits : bool , } impl MOSCRCSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CFDEVR { bits : bool , } impl CFDEVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Main Crystal Oscillator Status Interrupt Mask" ] # [ inline ] pub fn moscxts ( & self ) -> MOSCXTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCXTSR { bits } } # [ doc = "Bit 1 - PLLA Lock Interrupt Mask" ] # [ inline ] pub fn locka ( & self ) -> LOCKAR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOCKAR { bits } } # [ doc = "Bit 3 - Master Clock Ready Interrupt Mask" ] # [ inline ] pub fn mckrdy ( & self ) -> MCKRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MCKRDYR { bits } } # [ doc = "Bit 6 - UTMI PLL Lock Interrupt Mask" ] # [ inline ] pub fn locku ( & self ) -> LOCKUR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LOCKUR { bits } } # [ doc = "Bit 8 - Programmable Clock Ready 0 Interrupt Mask" ] # [ inline ] pub fn pckrdy0 ( & self ) -> PCKRDY0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCKRDY0R { bits } } # [ doc = "Bit 9 - Programmable Clock Ready 1 Interrupt Mask" ] # [ inline ] pub fn pckrdy1 ( & self ) -> PCKRDY1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCKRDY1R { bits } } # [ doc = "Bit 10 - Programmable Clock Ready 2 Interrupt Mask" ] # [ inline ] pub fn pckrdy2 ( & self ) -> PCKRDY2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PCKRDY2R { bits } } # [ doc = "Bit 16 - Main Oscillator Selection Status Interrupt Mask" ] # [ inline ] pub fn moscsels ( & self ) -> MOSCSELSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCSELSR { bits } } # [ doc = "Bit 17 - Main On-Chip RC Status Interrupt Mask" ] # [ inline ] pub fn moscrcs ( & self ) -> MOSCRCSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MOSCRCSR { bits } } # [ doc = "Bit 18 - Clock Failure Detector Event Interrupt Mask" ] # [ inline ] pub fn cfdev ( & self ) -> CFDEVR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CFDEVR { bits } } } } # [ doc = "Fast Start-up Mode Register" ] pub struct PMC_FSMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fast Start-up Mode Register" ] pub mod pmc_fsmr { # [ 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 :: PMC_FSMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FSTT0R { bits : bool , } impl FSTT0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT1R { bits : bool , } impl FSTT1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT2R { bits : bool , } impl FSTT2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT3R { bits : bool , } impl FSTT3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT4R { bits : bool , } impl FSTT4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT5R { bits : bool , } impl FSTT5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT6R { bits : bool , } impl FSTT6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT7R { bits : bool , } impl FSTT7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT8R { bits : bool , } impl FSTT8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT9R { bits : bool , } impl FSTT9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT10R { bits : bool , } impl FSTT10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT11R { bits : bool , } impl FSTT11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT12R { bits : bool , } impl FSTT12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT13R { bits : bool , } impl FSTT13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT14R { bits : bool , } impl FSTT14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTT15R { bits : bool , } impl FSTT15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RTTALR { bits : bool , } impl RTTALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RTCALR { bits : bool , } impl RTCALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct USBALR { bits : bool , } impl USBALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct LPMR { bits : bool , } impl LPMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _FSTT0W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT1W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT2W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT3W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT4W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT5W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT6W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT7W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT8W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT9W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT10W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT11W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT12W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT13W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT14W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTT15W < 'a > { w : & 'a mut W , } impl < 'a > _FSTT15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTTALW < 'a > { w : & 'a mut W , } impl < 'a > _RTTALW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTCALW < 'a > { w : & 'a mut W , } impl < 'a > _RTCALW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _USBALW < 'a > { w : & 'a mut W , } impl < 'a > _USBALW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _LPMW < 'a > { w : & 'a mut W , } impl < 'a > _LPMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Fast Start-up Input Enable 0" ] # [ inline ] pub fn fstt0 ( & self ) -> FSTT0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT0R { bits } } # [ doc = "Bit 1 - Fast Start-up Input Enable 1" ] # [ inline ] pub fn fstt1 ( & self ) -> FSTT1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT1R { bits } } # [ doc = "Bit 2 - Fast Start-up Input Enable 2" ] # [ inline ] pub fn fstt2 ( & self ) -> FSTT2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT2R { bits } } # [ doc = "Bit 3 - Fast Start-up Input Enable 3" ] # [ inline ] pub fn fstt3 ( & self ) -> FSTT3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT3R { bits } } # [ doc = "Bit 4 - Fast Start-up Input Enable 4" ] # [ inline ] pub fn fstt4 ( & self ) -> FSTT4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT4R { bits } } # [ doc = "Bit 5 - Fast Start-up Input Enable 5" ] # [ inline ] pub fn fstt5 ( & self ) -> FSTT5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT5R { bits } } # [ doc = "Bit 6 - Fast Start-up Input Enable 6" ] # [ inline ] pub fn fstt6 ( & self ) -> FSTT6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT6R { bits } } # [ doc = "Bit 7 - Fast Start-up Input Enable 7" ] # [ inline ] pub fn fstt7 ( & self ) -> FSTT7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT7R { bits } } # [ doc = "Bit 8 - Fast Start-up Input Enable 8" ] # [ inline ] pub fn fstt8 ( & self ) -> FSTT8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT8R { bits } } # [ doc = "Bit 9 - Fast Start-up Input Enable 9" ] # [ inline ] pub fn fstt9 ( & self ) -> FSTT9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT9R { bits } } # [ doc = "Bit 10 - Fast Start-up Input Enable 10" ] # [ inline ] pub fn fstt10 ( & self ) -> FSTT10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT10R { bits } } # [ doc = "Bit 11 - Fast Start-up Input Enable 11" ] # [ inline ] pub fn fstt11 ( & self ) -> FSTT11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT11R { bits } } # [ doc = "Bit 12 - Fast Start-up Input Enable 12" ] # [ inline ] pub fn fstt12 ( & self ) -> FSTT12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT12R { bits } } # [ doc = "Bit 13 - Fast Start-up Input Enable 13" ] # [ inline ] pub fn fstt13 ( & self ) -> FSTT13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT13R { bits } } # [ doc = "Bit 14 - Fast Start-up Input Enable 14" ] # [ inline ] pub fn fstt14 ( & self ) -> FSTT14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT14R { bits } } # [ doc = "Bit 15 - Fast Start-up Input Enable 15" ] # [ inline ] pub fn fstt15 ( & self ) -> FSTT15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTT15R { bits } } # [ doc = "Bit 16 - RTT Alarm Enable" ] # [ inline ] pub fn rttal ( & self ) -> RTTALR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTTALR { bits } } # [ doc = "Bit 17 - RTC Alarm Enable" ] # [ inline ] pub fn rtcal ( & self ) -> RTCALR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTCALR { bits } } # [ doc = "Bit 18 - USB Alarm Enable" ] # [ inline ] pub fn usbal ( & self ) -> USBALR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; USBALR { bits } } # [ doc = "Bit 20 - Low Power Mode" ] # [ inline ] pub fn lpm ( & self ) -> LPMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; LPMR { 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 - Fast Start-up Input Enable 0" ] # [ inline ] pub fn fstt0 ( & mut self ) -> _FSTT0W { _FSTT0W { w : self } } # [ doc = "Bit 1 - Fast Start-up Input Enable 1" ] # [ inline ] pub fn fstt1 ( & mut self ) -> _FSTT1W { _FSTT1W { w : self } } # [ doc = "Bit 2 - Fast Start-up Input Enable 2" ] # [ inline ] pub fn fstt2 ( & mut self ) -> _FSTT2W { _FSTT2W { w : self } } # [ doc = "Bit 3 - Fast Start-up Input Enable 3" ] # [ inline ] pub fn fstt3 ( & mut self ) -> _FSTT3W { _FSTT3W { w : self } } # [ doc = "Bit 4 - Fast Start-up Input Enable 4" ] # [ inline ] pub fn fstt4 ( & mut self ) -> _FSTT4W { _FSTT4W { w : self } } # [ doc = "Bit 5 - Fast Start-up Input Enable 5" ] # [ inline ] pub fn fstt5 ( & mut self ) -> _FSTT5W { _FSTT5W { w : self } } # [ doc = "Bit 6 - Fast Start-up Input Enable 6" ] # [ inline ] pub fn fstt6 ( & mut self ) -> _FSTT6W { _FSTT6W { w : self } } # [ doc = "Bit 7 - Fast Start-up Input Enable 7" ] # [ inline ] pub fn fstt7 ( & mut self ) -> _FSTT7W { _FSTT7W { w : self } } # [ doc = "Bit 8 - Fast Start-up Input Enable 8" ] # [ inline ] pub fn fstt8 ( & mut self ) -> _FSTT8W { _FSTT8W { w : self } } # [ doc = "Bit 9 - Fast Start-up Input Enable 9" ] # [ inline ] pub fn fstt9 ( & mut self ) -> _FSTT9W { _FSTT9W { w : self } } # [ doc = "Bit 10 - Fast Start-up Input Enable 10" ] # [ inline ] pub fn fstt10 ( & mut self ) -> _FSTT10W { _FSTT10W { w : self } } # [ doc = "Bit 11 - Fast Start-up Input Enable 11" ] # [ inline ] pub fn fstt11 ( & mut self ) -> _FSTT11W { _FSTT11W { w : self } } # [ doc = "Bit 12 - Fast Start-up Input Enable 12" ] # [ inline ] pub fn fstt12 ( & mut self ) -> _FSTT12W { _FSTT12W { w : self } } # [ doc = "Bit 13 - Fast Start-up Input Enable 13" ] # [ inline ] pub fn fstt13 ( & mut self ) -> _FSTT13W { _FSTT13W { w : self } } # [ doc = "Bit 14 - Fast Start-up Input Enable 14" ] # [ inline ] pub fn fstt14 ( & mut self ) -> _FSTT14W { _FSTT14W { w : self } } # [ doc = "Bit 15 - Fast Start-up Input Enable 15" ] # [ inline ] pub fn fstt15 ( & mut self ) -> _FSTT15W { _FSTT15W { w : self } } # [ doc = "Bit 16 - RTT Alarm Enable" ] # [ inline ] pub fn rttal ( & mut self ) -> _RTTALW { _RTTALW { w : self } } # [ doc = "Bit 17 - RTC Alarm Enable" ] # [ inline ] pub fn rtcal ( & mut self ) -> _RTCALW { _RTCALW { w : self } } # [ doc = "Bit 18 - USB Alarm Enable" ] # [ inline ] pub fn usbal ( & mut self ) -> _USBALW { _USBALW { w : self } } # [ doc = "Bit 20 - Low Power Mode" ] # [ inline ] pub fn lpm ( & mut self ) -> _LPMW { _LPMW { w : self } } } } # [ doc = "Fast Start-up Polarity Register" ] pub struct PMC_FSPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fast Start-up Polarity Register" ] pub mod pmc_fspr { # [ 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 :: PMC_FSPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FSTP0R { bits : bool , } impl FSTP0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP1R { bits : bool , } impl FSTP1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP2R { bits : bool , } impl FSTP2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP3R { bits : bool , } impl FSTP3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP4R { bits : bool , } impl FSTP4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP5R { bits : bool , } impl FSTP5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP6R { bits : bool , } impl FSTP6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP7R { bits : bool , } impl FSTP7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP8R { bits : bool , } impl FSTP8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP9R { bits : bool , } impl FSTP9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP10R { bits : bool , } impl FSTP10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP11R { bits : bool , } impl FSTP11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP12R { bits : bool , } impl FSTP12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP13R { bits : bool , } impl FSTP13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP14R { bits : bool , } impl FSTP14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FSTP15R { bits : bool , } impl FSTP15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _FSTP0W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP1W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP2W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP3W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP4W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP5W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP6W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP7W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP8W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP9W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP10W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP11W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP12W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP13W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP14W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FSTP15W < 'a > { w : & 'a mut W , } impl < 'a > _FSTP15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp0 ( & self ) -> FSTP0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP0R { bits } } # [ doc = "Bit 1 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp1 ( & self ) -> FSTP1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP1R { bits } } # [ doc = "Bit 2 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp2 ( & self ) -> FSTP2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP2R { bits } } # [ doc = "Bit 3 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp3 ( & self ) -> FSTP3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP3R { bits } } # [ doc = "Bit 4 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp4 ( & self ) -> FSTP4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP4R { bits } } # [ doc = "Bit 5 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp5 ( & self ) -> FSTP5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP5R { bits } } # [ doc = "Bit 6 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp6 ( & self ) -> FSTP6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP6R { bits } } # [ doc = "Bit 7 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp7 ( & self ) -> FSTP7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP7R { bits } } # [ doc = "Bit 8 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp8 ( & self ) -> FSTP8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP8R { bits } } # [ doc = "Bit 9 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp9 ( & self ) -> FSTP9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP9R { bits } } # [ doc = "Bit 10 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp10 ( & self ) -> FSTP10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP10R { bits } } # [ doc = "Bit 11 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp11 ( & self ) -> FSTP11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP11R { bits } } # [ doc = "Bit 12 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp12 ( & self ) -> FSTP12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP12R { bits } } # [ doc = "Bit 13 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp13 ( & self ) -> FSTP13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP13R { bits } } # [ doc = "Bit 14 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp14 ( & self ) -> FSTP14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP14R { bits } } # [ doc = "Bit 15 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp15 ( & self ) -> FSTP15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FSTP15R { 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 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp0 ( & mut self ) -> _FSTP0W { _FSTP0W { w : self } } # [ doc = "Bit 1 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp1 ( & mut self ) -> _FSTP1W { _FSTP1W { w : self } } # [ doc = "Bit 2 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp2 ( & mut self ) -> _FSTP2W { _FSTP2W { w : self } } # [ doc = "Bit 3 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp3 ( & mut self ) -> _FSTP3W { _FSTP3W { w : self } } # [ doc = "Bit 4 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp4 ( & mut self ) -> _FSTP4W { _FSTP4W { w : self } } # [ doc = "Bit 5 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp5 ( & mut self ) -> _FSTP5W { _FSTP5W { w : self } } # [ doc = "Bit 6 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp6 ( & mut self ) -> _FSTP6W { _FSTP6W { w : self } } # [ doc = "Bit 7 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp7 ( & mut self ) -> _FSTP7W { _FSTP7W { w : self } } # [ doc = "Bit 8 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp8 ( & mut self ) -> _FSTP8W { _FSTP8W { w : self } } # [ doc = "Bit 9 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp9 ( & mut self ) -> _FSTP9W { _FSTP9W { w : self } } # [ doc = "Bit 10 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp10 ( & mut self ) -> _FSTP10W { _FSTP10W { w : self } } # [ doc = "Bit 11 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp11 ( & mut self ) -> _FSTP11W { _FSTP11W { w : self } } # [ doc = "Bit 12 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp12 ( & mut self ) -> _FSTP12W { _FSTP12W { w : self } } # [ doc = "Bit 13 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp13 ( & mut self ) -> _FSTP13W { _FSTP13W { w : self } } # [ doc = "Bit 14 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp14 ( & mut self ) -> _FSTP14W { _FSTP14W { w : self } } # [ doc = "Bit 15 - Fast Start-up Input Polarityx" ] # [ inline ] pub fn fstp15 ( & mut self ) -> _FSTP15W { _FSTP15W { w : self } } } } # [ doc = "Fault Output Clear Register" ] pub struct PMC_FOCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fault Output Clear Register" ] pub mod pmc_focr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_FOCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _FOCLRW < 'a > { w : & 'a mut W , } impl < 'a > _FOCLRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bit 0 - Fault Output Clear" ] # [ inline ] pub fn foclr ( & mut self ) -> _FOCLRW { _FOCLRW { w : self } } } } # [ doc = "Write Protect Mode Register" ] pub struct PMC_WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod pmc_wpmr { # [ 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 :: PMC_WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0050_4d43 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5262659 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5262659 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit. Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct PMC_WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod pmc_wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PMC_WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } # [ doc = "Peripheral Clock Enable Register 1" ] pub struct PMC_PCER1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral Clock Enable Register 1" ] pub mod pmc_pcer1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_PCER1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _PID32W < 'a > { w : & 'a mut W , } impl < 'a > _PID32W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID33W < 'a > { w : & 'a mut W , } impl < 'a > _PID33W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID34W < 'a > { w : & 'a mut W , } impl < 'a > _PID34W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID35W < 'a > { w : & 'a mut W , } impl < 'a > _PID35W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID36W < 'a > { w : & 'a mut W , } impl < 'a > _PID36W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID37W < 'a > { w : & 'a mut W , } impl < 'a > _PID37W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID38W < 'a > { w : & 'a mut W , } impl < 'a > _PID38W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID39W < 'a > { w : & 'a mut W , } impl < 'a > _PID39W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID40W < 'a > { w : & 'a mut W , } impl < 'a > _PID40W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID41W < 'a > { w : & 'a mut W , } impl < 'a > _PID41W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID42W < 'a > { w : & 'a mut W , } impl < 'a > _PID42W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID43W < 'a > { w : & 'a mut W , } impl < 'a > _PID43W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID44W < 'a > { w : & 'a mut W , } impl < 'a > _PID44W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Peripheral Clock 32 Enable" ] # [ inline ] pub fn pid32 ( & mut self ) -> _PID32W { _PID32W { w : self } } # [ doc = "Bit 1 - Peripheral Clock 33 Enable" ] # [ inline ] pub fn pid33 ( & mut self ) -> _PID33W { _PID33W { w : self } } # [ doc = "Bit 2 - Peripheral Clock 34 Enable" ] # [ inline ] pub fn pid34 ( & mut self ) -> _PID34W { _PID34W { w : self } } # [ doc = "Bit 3 - Peripheral Clock 35 Enable" ] # [ inline ] pub fn pid35 ( & mut self ) -> _PID35W { _PID35W { w : self } } # [ doc = "Bit 4 - Peripheral Clock 36 Enable" ] # [ inline ] pub fn pid36 ( & mut self ) -> _PID36W { _PID36W { w : self } } # [ doc = "Bit 5 - Peripheral Clock 37 Enable" ] # [ inline ] pub fn pid37 ( & mut self ) -> _PID37W { _PID37W { w : self } } # [ doc = "Bit 6 - Peripheral Clock 38 Enable" ] # [ inline ] pub fn pid38 ( & mut self ) -> _PID38W { _PID38W { w : self } } # [ doc = "Bit 7 - Peripheral Clock 39 Enable" ] # [ inline ] pub fn pid39 ( & mut self ) -> _PID39W { _PID39W { w : self } } # [ doc = "Bit 8 - Peripheral Clock 40 Enable" ] # [ inline ] pub fn pid40 ( & mut self ) -> _PID40W { _PID40W { w : self } } # [ doc = "Bit 9 - Peripheral Clock 41 Enable" ] # [ inline ] pub fn pid41 ( & mut self ) -> _PID41W { _PID41W { w : self } } # [ doc = "Bit 10 - Peripheral Clock 42 Enable" ] # [ inline ] pub fn pid42 ( & mut self ) -> _PID42W { _PID42W { w : self } } # [ doc = "Bit 11 - Peripheral Clock 43 Enable" ] # [ inline ] pub fn pid43 ( & mut self ) -> _PID43W { _PID43W { w : self } } # [ doc = "Bit 12 - Peripheral Clock 44 Enable" ] # [ inline ] pub fn pid44 ( & mut self ) -> _PID44W { _PID44W { w : self } } } } # [ doc = "Peripheral Clock Disable Register 1" ] pub struct PMC_PCDR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral Clock Disable Register 1" ] pub mod pmc_pcdr1 { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PMC_PCDR1 { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _PID32W < 'a > { w : & 'a mut W , } impl < 'a > _PID32W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID33W < 'a > { w : & 'a mut W , } impl < 'a > _PID33W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID34W < 'a > { w : & 'a mut W , } impl < 'a > _PID34W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID35W < 'a > { w : & 'a mut W , } impl < 'a > _PID35W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID36W < 'a > { w : & 'a mut W , } impl < 'a > _PID36W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID37W < 'a > { w : & 'a mut W , } impl < 'a > _PID37W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID38W < 'a > { w : & 'a mut W , } impl < 'a > _PID38W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID39W < 'a > { w : & 'a mut W , } impl < 'a > _PID39W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID40W < 'a > { w : & 'a mut W , } impl < 'a > _PID40W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID41W < 'a > { w : & 'a mut W , } impl < 'a > _PID41W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID42W < 'a > { w : & 'a mut W , } impl < 'a > _PID42W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID43W < 'a > { w : & 'a mut W , } impl < 'a > _PID43W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PID44W < 'a > { w : & 'a mut W , } impl < 'a > _PID44W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Peripheral Clock 32 Disable" ] # [ inline ] pub fn pid32 ( & mut self ) -> _PID32W { _PID32W { w : self } } # [ doc = "Bit 1 - Peripheral Clock 33 Disable" ] # [ inline ] pub fn pid33 ( & mut self ) -> _PID33W { _PID33W { w : self } } # [ doc = "Bit 2 - Peripheral Clock 34 Disable" ] # [ inline ] pub fn pid34 ( & mut self ) -> _PID34W { _PID34W { w : self } } # [ doc = "Bit 3 - Peripheral Clock 35 Disable" ] # [ inline ] pub fn pid35 ( & mut self ) -> _PID35W { _PID35W { w : self } } # [ doc = "Bit 4 - Peripheral Clock 36 Disable" ] # [ inline ] pub fn pid36 ( & mut self ) -> _PID36W { _PID36W { w : self } } # [ doc = "Bit 5 - Peripheral Clock 37 Disable" ] # [ inline ] pub fn pid37 ( & mut self ) -> _PID37W { _PID37W { w : self } } # [ doc = "Bit 6 - Peripheral Clock 38 Disable" ] # [ inline ] pub fn pid38 ( & mut self ) -> _PID38W { _PID38W { w : self } } # [ doc = "Bit 7 - Peripheral Clock 39 Disable" ] # [ inline ] pub fn pid39 ( & mut self ) -> _PID39W { _PID39W { w : self } } # [ doc = "Bit 8 - Peripheral Clock 40 Disable" ] # [ inline ] pub fn pid40 ( & mut self ) -> _PID40W { _PID40W { w : self } } # [ doc = "Bit 9 - Peripheral Clock 41 Disable" ] # [ inline ] pub fn pid41 ( & mut self ) -> _PID41W { _PID41W { w : self } } # [ doc = "Bit 10 - Peripheral Clock 42 Disable" ] # [ inline ] pub fn pid42 ( & mut self ) -> _PID42W { _PID42W { w : self } } # [ doc = "Bit 11 - Peripheral Clock 43 Disable" ] # [ inline ] pub fn pid43 ( & mut self ) -> _PID43W { _PID43W { w : self } } # [ doc = "Bit 12 - Peripheral Clock 44 Disable" ] # [ inline ] pub fn pid44 ( & mut self ) -> _PID44W { _PID44W { w : self } } } } # [ doc = "Peripheral Clock Status Register 1" ] pub struct PMC_PCSR1 { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral Clock Status Register 1" ] pub mod pmc_pcsr1 { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PMC_PCSR1 { # [ 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 PID32R { bits : bool , } impl PID32R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID33R { bits : bool , } impl PID33R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID34R { bits : bool , } impl PID34R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID35R { bits : bool , } impl PID35R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID36R { bits : bool , } impl PID36R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID37R { bits : bool , } impl PID37R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID38R { bits : bool , } impl PID38R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID39R { bits : bool , } impl PID39R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID40R { bits : bool , } impl PID40R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID41R { bits : bool , } impl PID41R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID42R { bits : bool , } impl PID42R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID43R { bits : bool , } impl PID43R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PID44R { bits : bool , } impl PID44R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Peripheral Clock 32 Status" ] # [ inline ] pub fn pid32 ( & self ) -> PID32R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID32R { bits } } # [ doc = "Bit 1 - Peripheral Clock 33 Status" ] # [ inline ] pub fn pid33 ( & self ) -> PID33R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID33R { bits } } # [ doc = "Bit 2 - Peripheral Clock 34 Status" ] # [ inline ] pub fn pid34 ( & self ) -> PID34R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID34R { bits } } # [ doc = "Bit 3 - Peripheral Clock 35 Status" ] # [ inline ] pub fn pid35 ( & self ) -> PID35R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID35R { bits } } # [ doc = "Bit 4 - Peripheral Clock 36 Status" ] # [ inline ] pub fn pid36 ( & self ) -> PID36R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID36R { bits } } # [ doc = "Bit 5 - Peripheral Clock 37 Status" ] # [ inline ] pub fn pid37 ( & self ) -> PID37R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID37R { bits } } # [ doc = "Bit 6 - Peripheral Clock 38 Status" ] # [ inline ] pub fn pid38 ( & self ) -> PID38R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID38R { bits } } # [ doc = "Bit 7 - Peripheral Clock 39 Status" ] # [ inline ] pub fn pid39 ( & self ) -> PID39R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID39R { bits } } # [ doc = "Bit 8 - Peripheral Clock 40 Status" ] # [ inline ] pub fn pid40 ( & self ) -> PID40R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID40R { bits } } # [ doc = "Bit 9 - Peripheral Clock 41 Status" ] # [ inline ] pub fn pid41 ( & self ) -> PID41R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID41R { bits } } # [ doc = "Bit 10 - Peripheral Clock 42 Status" ] # [ inline ] pub fn pid42 ( & self ) -> PID42R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID42R { bits } } # [ doc = "Bit 11 - Peripheral Clock 43 Status" ] # [ inline ] pub fn pid43 ( & self ) -> PID43R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID43R { bits } } # [ doc = "Bit 12 - Peripheral Clock 44 Status" ] # [ inline ] pub fn pid44 ( & self ) -> PID44R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PID44R { bits } } } } # [ doc = "Peripheral Control Register" ] pub struct PMC_PCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral Control Register" ] pub mod pmc_pcr { # [ 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 :: PMC_PCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 PIDR { bits : u8 , } impl PIDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct CMDR { bits : bool , } impl CMDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `DIV`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum DIVR { # [ doc = "Peripheral clock is MCK" ] PERIPH_DIV_MCK , # [ doc = "Peripheral clock is MCK/2" ] PERIPH_DIV2_MCK , # [ doc = "Peripheral clock is MCK/4" ] PERIPH_DIV4_MCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl DIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { DIVR :: PERIPH_DIV_MCK => 0 , DIVR :: PERIPH_DIV2_MCK => 0x01 , DIVR :: PERIPH_DIV4_MCK => 0x02 , DIVR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> DIVR { match value { 0 => DIVR :: PERIPH_DIV_MCK , 1 => DIVR :: PERIPH_DIV2_MCK , 2 => DIVR :: PERIPH_DIV4_MCK , i => DIVR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PERIPH_DIV_MCK`" ] # [ inline ] pub fn is_periph_div_mck ( & self ) -> bool { * self == DIVR :: PERIPH_DIV_MCK } # [ doc = "Checks if the value of the field is `PERIPH_DIV2_MCK`" ] # [ inline ] pub fn is_periph_div2_mck ( & self ) -> bool { * self == DIVR :: PERIPH_DIV2_MCK } # [ doc = "Checks if the value of the field is `PERIPH_DIV4_MCK`" ] # [ inline ] pub fn is_periph_div4_mck ( & self ) -> bool { * self == DIVR :: PERIPH_DIV4_MCK } } # [ 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" Proxy" ] pub struct _PIDW < 'a > { w : & 'a mut W , } impl < 'a > _PIDW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _CMDW < 'a > { w : & 'a mut W , } impl < 'a > _CMDW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `DIV`" ] pub enum DIVW { # [ doc = "Peripheral clock is MCK" ] PERIPH_DIV_MCK , # [ doc = "Peripheral clock is MCK/2" ] PERIPH_DIV2_MCK , # [ doc = "Peripheral clock is MCK/4" ] PERIPH_DIV4_MCK } impl DIVW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { DIVW :: PERIPH_DIV_MCK => 0 , DIVW :: PERIPH_DIV2_MCK => 1 , DIVW :: PERIPH_DIV4_MCK => 2 } } } # [ doc = r" Proxy" ] pub struct _DIVW < 'a > { w : & 'a mut W , } impl < 'a > _DIVW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : DIVW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Peripheral clock is MCK" ] # [ inline ] pub fn periph_div_mck ( self ) -> & 'a mut W { self . variant ( DIVW :: PERIPH_DIV_MCK ) } # [ doc = "Peripheral clock is MCK/2" ] # [ inline ] pub fn periph_div2_mck ( self ) -> & 'a mut W { self . variant ( DIVW :: PERIPH_DIV2_MCK ) } # [ doc = "Peripheral clock is MCK/4" ] # [ inline ] pub fn periph_div4_mck ( self ) -> & 'a mut W { self . variant ( DIVW :: PERIPH_DIV4_MCK ) } # [ 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 _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 = 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:5 - Peripheral ID" ] # [ inline ] pub fn pid ( & self ) -> PIDR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; PIDR { bits } } # [ doc = "Bit 12 - Command" ] # [ inline ] pub fn cmd ( & self ) -> CMDR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CMDR { bits } } # [ doc = "Bits 16:17 - Divisor Value" ] # [ inline ] pub fn div ( & self ) -> DIVR { DIVR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 28 - Enable" ] # [ inline ] pub fn en ( & self ) -> ENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENR { 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:5 - Peripheral ID" ] # [ inline ] pub fn pid ( & mut self ) -> _PIDW { _PIDW { w : self } } # [ doc = "Bit 12 - Command" ] # [ inline ] pub fn cmd ( & mut self ) -> _CMDW { _CMDW { w : self } } # [ doc = "Bits 16:17 - Divisor Value" ] # [ inline ] pub fn div ( & mut self ) -> _DIVW { _DIVW { w : self } } # [ doc = "Bit 28 - Enable" ] # [ inline ] pub fn en ( & mut self ) -> _ENW { _ENW { w : self } } } } } # [ doc = "Universal Asynchronous Receiver Transmitter" ] pub struct UART { _marker : PhantomData < * const ( ) > } unsafe impl Send for UART { } impl UART { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const uart :: RegisterBlock { 0x400e_0800 as * const _ } } impl Deref for UART { type Target = uart :: RegisterBlock ; fn deref ( & self ) -> & uart :: RegisterBlock { unsafe { & * UART :: ptr ( ) } } } # [ doc = "Universal Asynchronous Receiver Transmitter" ] pub mod uart { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Mode Register" ] pub mr : MR , # [ doc = "0x08 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x0c - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x10 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x14 - Status Register" ] pub sr : SR , # [ doc = "0x18 - Receive Holding Register" ] pub rhr : RHR , # [ doc = "0x1c - Transmit Holding Register" ] pub thr : THR , # [ doc = "0x20 - Baud Rate Generator Register" ] pub brgr : BRGR , _reserved9 : [ u8 ; 220usize ] , # [ doc = "0x100 - Receive Pointer Register" ] pub rpr : RPR , # [ doc = "0x104 - Receive Counter Register" ] pub rcr : RCR , # [ doc = "0x108 - Transmit Pointer Register" ] pub tpr : TPR , # [ doc = "0x10c - Transmit Counter Register" ] pub tcr : TCR , # [ doc = "0x110 - Receive Next Pointer Register" ] pub rnpr : RNPR , # [ doc = "0x114 - Receive Next Counter Register" ] pub rncr : RNCR , # [ doc = "0x118 - Transmit Next Pointer Register" ] pub tnpr : TNPR , # [ doc = "0x11c - Transmit Next Counter Register" ] pub tncr : TNCR , # [ doc = "0x120 - Transfer Control Register" ] pub ptcr : PTCR , # [ doc = "0x124 - Transfer Status Register" ] pub ptsr : PTSR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RSTRXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTTXW < 'a > { w : & 'a mut W , } impl < 'a > _RSTTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXENW < 'a > { w : & 'a mut W , } impl < 'a > _RXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXENW < 'a > { w : & 'a mut W , } impl < 'a > _TXENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RSTSTAW < 'a > { w : & 'a mut W , } impl < 'a > _RSTSTAW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 2 - Reset Receiver" ] # [ inline ] pub fn rstrx ( & mut self ) -> _RSTRXW { _RSTRXW { w : self } } # [ doc = "Bit 3 - Reset Transmitter" ] # [ inline ] pub fn rsttx ( & mut self ) -> _RSTTXW { _RSTTXW { w : self } } # [ doc = "Bit 4 - Receiver Enable" ] # [ inline ] pub fn rxen ( & mut self ) -> _RXENW { _RXENW { w : self } } # [ doc = "Bit 5 - Receiver Disable" ] # [ inline ] pub fn rxdis ( & mut self ) -> _RXDISW { _RXDISW { w : self } } # [ doc = "Bit 6 - Transmitter Enable" ] # [ inline ] pub fn txen ( & mut self ) -> _TXENW { _TXENW { w : self } } # [ doc = "Bit 7 - Transmitter Disable" ] # [ inline ] pub fn txdis ( & mut self ) -> _TXDISW { _TXDISW { w : self } } # [ doc = "Bit 8 - Reset Status Bits" ] # [ inline ] pub fn rststa ( & mut self ) -> _RSTSTAW { _RSTSTAW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `PAR`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum PARR { # [ doc = "Even Parity" ] EVEN , # [ doc = "Odd Parity" ] ODD , # [ doc = "Space: parity forced to 0" ] SPACE , # [ doc = "Mark: parity forced to 1" ] MARK , # [ doc = "No Parity" ] NO , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl PARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { PARR :: EVEN => 0 , PARR :: ODD => 0x01 , PARR :: SPACE => 0x02 , PARR :: MARK => 0x03 , PARR :: NO => 0x04 , PARR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> PARR { match value { 0 => PARR :: EVEN , 1 => PARR :: ODD , 2 => PARR :: SPACE , 3 => PARR :: MARK , 4 => PARR :: NO , i => PARR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `EVEN`" ] # [ inline ] pub fn is_even ( & self ) -> bool { * self == PARR :: EVEN } # [ doc = "Checks if the value of the field is `ODD`" ] # [ inline ] pub fn is_odd ( & self ) -> bool { * self == PARR :: ODD } # [ doc = "Checks if the value of the field is `SPACE`" ] # [ inline ] pub fn is_space ( & self ) -> bool { * self == PARR :: SPACE } # [ doc = "Checks if the value of the field is `MARK`" ] # [ inline ] pub fn is_mark ( & self ) -> bool { * self == PARR :: MARK } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == PARR :: NO } } # [ doc = "Possible values of the field `CHMODE`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CHMODER { # [ doc = "Normal Mode" ] NORMAL , # [ doc = "Automatic Echo" ] AUTOMATIC , # [ doc = "Local Loopback" ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback" ] REMOTE_LOOPBACK } impl CHMODER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CHMODER :: NORMAL => 0 , CHMODER :: AUTOMATIC => 0x01 , CHMODER :: LOCAL_LOOPBACK => 0x02 , CHMODER :: REMOTE_LOOPBACK => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CHMODER { match value { 0 => CHMODER :: NORMAL , 1 => CHMODER :: AUTOMATIC , 2 => CHMODER :: LOCAL_LOOPBACK , 3 => CHMODER :: REMOTE_LOOPBACK , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `NORMAL`" ] # [ inline ] pub fn is_normal ( & self ) -> bool { * self == CHMODER :: NORMAL } # [ doc = "Checks if the value of the field is `AUTOMATIC`" ] # [ inline ] pub fn is_automatic ( & self ) -> bool { * self == CHMODER :: AUTOMATIC } # [ doc = "Checks if the value of the field is `LOCAL_LOOPBACK`" ] # [ inline ] pub fn is_local_loopback ( & self ) -> bool { * self == CHMODER :: LOCAL_LOOPBACK } # [ doc = "Checks if the value of the field is `REMOTE_LOOPBACK`" ] # [ inline ] pub fn is_remote_loopback ( & self ) -> bool { * self == CHMODER :: REMOTE_LOOPBACK } } # [ doc = "Values that can be written to the field `PAR`" ] pub enum PARW { # [ doc = "Even Parity" ] EVEN , # [ doc = "Odd Parity" ] ODD , # [ doc = "Space: parity forced to 0" ] SPACE , # [ doc = "Mark: parity forced to 1" ] MARK , # [ doc = "No Parity" ] NO } impl PARW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { PARW :: EVEN => 0 , PARW :: ODD => 1 , PARW :: SPACE => 2 , PARW :: MARK => 3 , PARW :: NO => 4 } } } # [ doc = r" Proxy" ] pub struct _PARW < 'a > { w : & 'a mut W , } impl < 'a > _PARW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : PARW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Even Parity" ] # [ inline ] pub fn even ( self ) -> & 'a mut W { self . variant ( PARW :: EVEN ) } # [ doc = "Odd Parity" ] # [ inline ] pub fn odd ( self ) -> & 'a mut W { self . variant ( PARW :: ODD ) } # [ doc = "Space: parity forced to 0" ] # [ inline ] pub fn space ( self ) -> & 'a mut W { self . variant ( PARW :: SPACE ) } # [ doc = "Mark: parity forced to 1" ] # [ inline ] pub fn mark ( self ) -> & 'a mut W { self . variant ( PARW :: MARK ) } # [ doc = "No Parity" ] # [ inline ] pub fn no ( self ) -> & 'a mut W { self . variant ( PARW :: NO ) } # [ 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 = 9 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `CHMODE`" ] pub enum CHMODEW { # [ doc = "Normal Mode" ] NORMAL , # [ doc = "Automatic Echo" ] AUTOMATIC , # [ doc = "Local Loopback" ] LOCAL_LOOPBACK , # [ doc = "Remote Loopback" ] REMOTE_LOOPBACK } impl CHMODEW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CHMODEW :: NORMAL => 0 , CHMODEW :: AUTOMATIC => 1 , CHMODEW :: LOCAL_LOOPBACK => 2 , CHMODEW :: REMOTE_LOOPBACK => 3 } } } # [ doc = r" Proxy" ] pub struct _CHMODEW < 'a > { w : & 'a mut W , } impl < 'a > _CHMODEW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CHMODEW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Normal Mode" ] # [ inline ] pub fn normal ( self ) -> & 'a mut W { self . variant ( CHMODEW :: NORMAL ) } # [ doc = "Automatic Echo" ] # [ inline ] pub fn automatic ( self ) -> & 'a mut W { self . variant ( CHMODEW :: AUTOMATIC ) } # [ doc = "Local Loopback" ] # [ inline ] pub fn local_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: LOCAL_LOOPBACK ) } # [ doc = "Remote Loopback" ] # [ inline ] pub fn remote_loopback ( self ) -> & 'a mut W { self . variant ( CHMODEW :: REMOTE_LOOPBACK ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 9:11 - Parity Type" ] # [ inline ] pub fn par ( & self ) -> PARR { PARR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & self ) -> CHMODER { CHMODER :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 9:11 - Parity Type" ] # [ inline ] pub fn par ( & mut self ) -> _PARW { _PARW { w : self } } # [ doc = "Bits 14:15 - Channel Mode" ] # [ inline ] pub fn chmode ( & mut self ) -> _CHMODEW { _CHMODEW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Enable RXRDY Interrupt" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - Enable TXRDY Interrupt" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3 - Enable End of Receive Transfer Interrupt" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - Enable End of Transmit Interrupt" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Enable Overrun Error Interrupt" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Enable Framing Error Interrupt" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Enable Parity Error Interrupt" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 9 - Enable TXEMPTY Interrupt" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11 - Enable Buffer Empty Interrupt" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Enable Buffer Full Interrupt" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _RXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _RXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXRDYW < 'a > { w : & 'a mut W , } impl < 'a > _TXRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDRXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDRXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ENDTXW < 'a > { w : & 'a mut W , } impl < 'a > _ENDTXW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _OVREW < 'a > { w : & 'a mut W , } impl < 'a > _OVREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FRAMEW < 'a > { w : & 'a mut W , } impl < 'a > _FRAMEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PAREW < 'a > { w : & 'a mut W , } impl < 'a > _PAREW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXEMPTYW < 'a > { w : & 'a mut W , } impl < 'a > _TXEMPTYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXBUFEW < 'a > { w : & 'a mut W , } impl < 'a > _TXBUFEW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXBUFFW < 'a > { w : & 'a mut W , } impl < 'a > _RXBUFFW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl W { # [ doc = "Bit 0 - Disable RXRDY Interrupt" ] # [ inline ] pub fn rxrdy ( & mut self ) -> _RXRDYW { _RXRDYW { w : self } } # [ doc = "Bit 1 - Disable TXRDY Interrupt" ] # [ inline ] pub fn txrdy ( & mut self ) -> _TXRDYW { _TXRDYW { w : self } } # [ doc = "Bit 3 - Disable End of Receive Transfer Interrupt" ] # [ inline ] pub fn endrx ( & mut self ) -> _ENDRXW { _ENDRXW { w : self } } # [ doc = "Bit 4 - Disable End of Transmit Interrupt" ] # [ inline ] pub fn endtx ( & mut self ) -> _ENDTXW { _ENDTXW { w : self } } # [ doc = "Bit 5 - Disable Overrun Error Interrupt" ] # [ inline ] pub fn ovre ( & mut self ) -> _OVREW { _OVREW { w : self } } # [ doc = "Bit 6 - Disable Framing Error Interrupt" ] # [ inline ] pub fn frame ( & mut self ) -> _FRAMEW { _FRAMEW { w : self } } # [ doc = "Bit 7 - Disable Parity Error Interrupt" ] # [ inline ] pub fn pare ( & mut self ) -> _PAREW { _PAREW { w : self } } # [ doc = "Bit 9 - Disable TXEMPTY Interrupt" ] # [ inline ] pub fn txempty ( & mut self ) -> _TXEMPTYW { _TXEMPTYW { w : self } } # [ doc = "Bit 11 - Disable Buffer Empty Interrupt" ] # [ inline ] pub fn txbufe ( & mut self ) -> _TXBUFEW { _TXBUFEW { w : self } } # [ doc = "Bit 12 - Disable Buffer Full Interrupt" ] # [ inline ] pub fn rxbuff ( & mut self ) -> _RXBUFFW { _RXBUFFW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Mask RXRDY Interrupt" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Disable TXRDY Interrupt" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3 - Mask End of Receive Transfer Interrupt" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - Mask End of Transmit Interrupt" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Mask Overrun Error Interrupt" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Mask Framing Error Interrupt" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Mask Parity Error Interrupt" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 9 - Mask TXEMPTY Interrupt" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11 - Mask TXBUFE Interrupt" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Mask RXBUFF Interrupt" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 RXRDYR { bits : bool , } impl RXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXRDYR { bits : bool , } impl TXRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDRXR { bits : bool , } impl ENDRXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ENDTXR { bits : bool , } impl ENDTXR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct OVRER { bits : bool , } impl OVRER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FRAMER { bits : bool , } impl FRAMER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct PARER { bits : bool , } impl PARER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXEMPTYR { bits : bool , } impl TXEMPTYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXBUFER { bits : bool , } impl TXBUFER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RXBUFFR { bits : bool , } impl RXBUFFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Ready" ] # [ inline ] pub fn rxrdy ( & self ) -> RXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXRDYR { bits } } # [ doc = "Bit 1 - Transmitter Ready" ] # [ inline ] pub fn txrdy ( & self ) -> TXRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXRDYR { bits } } # [ doc = "Bit 3 - End of Receiver Transfer" ] # [ inline ] pub fn endrx ( & self ) -> ENDRXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDRXR { bits } } # [ doc = "Bit 4 - End of Transmitter Transfer" ] # [ inline ] pub fn endtx ( & self ) -> ENDTXR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ENDTXR { bits } } # [ doc = "Bit 5 - Overrun Error" ] # [ inline ] pub fn ovre ( & self ) -> OVRER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; OVRER { bits } } # [ doc = "Bit 6 - Framing Error" ] # [ inline ] pub fn frame ( & self ) -> FRAMER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRAMER { bits } } # [ doc = "Bit 7 - Parity Error" ] # [ inline ] pub fn pare ( & self ) -> PARER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; PARER { bits } } # [ doc = "Bit 9 - Transmitter Empty" ] # [ inline ] pub fn txempty ( & self ) -> TXEMPTYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXEMPTYR { bits } } # [ doc = "Bit 11 - Transmission Buffer Empty" ] # [ inline ] pub fn txbufe ( & self ) -> TXBUFER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXBUFER { bits } } # [ doc = "Bit 12 - Receive Buffer Full" ] # [ inline ] pub fn rxbuff ( & self ) -> RXBUFFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXBUFFR { bits } } } } # [ doc = "Receive Holding Register" ] pub struct RHR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Holding Register" ] pub mod rhr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: RHR { # [ 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 RXCHRR { bits : u8 , } impl RXCHRR { # [ 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 - Received Character" ] # [ inline ] pub fn rxchr ( & self ) -> RXCHRR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; RXCHRR { bits } } } } # [ doc = "Transmit Holding Register" ] pub struct THR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Holding Register" ] pub mod thr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: THR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _TXCHRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCHRW < '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 = "Bits 0:7 - Character to be Transmitted" ] # [ inline ] pub fn txchr ( & mut self ) -> _TXCHRW { _TXCHRW { w : self } } } } # [ doc = "Baud Rate Generator Register" ] pub struct BRGR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Baud Rate Generator Register" ] pub mod brgr { # [ 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 :: BRGR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 CDR { bits : u16 , } impl CDR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _CDW < 'a > { w : & 'a mut W , } impl < 'a > _CDW < '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 - Clock Divisor" ] # [ inline ] pub fn cd ( & self ) -> CDR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; CDR { 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 - Clock Divisor" ] # [ inline ] pub fn cd ( & mut self ) -> _CDW { _CDW { w : self } } } } # [ doc = "Receive Pointer Register" ] pub struct RPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Pointer Register" ] pub mod rpr { # [ 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 :: RPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXPTRR { bits : u32 , } impl RXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXPTRW < '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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & self ) -> RXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXPTRR { 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 - Receive Pointer Register" ] # [ inline ] pub fn rxptr ( & mut self ) -> _RXPTRW { _RXPTRW { w : self } } } } # [ doc = "Receive Counter Register" ] pub struct RCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive 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 < F > ( & 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 < F > ( & 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 RXCTRR { bits : u16 , } impl RXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXCTRW < '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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & self ) -> RXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXCTRR { 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 - Receive Counter Register" ] # [ inline ] pub fn rxctr ( & mut self ) -> _RXCTRW { _RXCTRW { w : self } } } } # [ doc = "Transmit Pointer Register" ] pub struct TPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Pointer Register" ] pub mod tpr { # [ 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 :: TPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXPTRR { bits : u32 , } impl TXPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXPTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & self ) -> TXPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXPTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txptr ( & mut self ) -> _TXPTRW { _TXPTRW { w : self } } } } # [ doc = "Transmit Counter Register" ] pub struct TCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Counter Register" ] pub mod tcr { # [ 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 :: TCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXCTRR { bits : u16 , } impl TXCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXCTRW < '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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & self ) -> TXCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXCTRR { 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 - Transmit Counter Register" ] # [ inline ] pub fn txctr ( & mut self ) -> _TXCTRW { _TXCTRW { w : self } } } } # [ doc = "Receive Next Pointer Register" ] pub struct RNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Pointer Register" ] pub mod rnpr { # [ 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 :: RNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNPTRR { bits : u32 , } impl RXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNPTRW < '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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & self ) -> RXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; RXNPTRR { 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 - Receive Next Pointer" ] # [ inline ] pub fn rxnptr ( & mut self ) -> _RXNPTRW { _RXNPTRW { w : self } } } } # [ doc = "Receive Next Counter Register" ] pub struct RNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Receive Next Counter Register" ] pub mod rncr { # [ 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 :: RNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RXNCTRR { bits : u16 , } impl RXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _RXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _RXNCTRW < '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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & self ) -> RXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RXNCTRR { 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 - Receive Next Counter" ] # [ inline ] pub fn rxnctr ( & mut self ) -> _RXNCTRW { _RXNCTRW { w : self } } } } # [ doc = "Transmit Next Pointer Register" ] pub struct TNPR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Pointer Register" ] pub mod tnpr { # [ 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 :: TNPR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNPTRR { bits : u32 , } impl TXNPTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNPTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNPTRW < '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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & self ) -> TXNPTRR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; TXNPTRR { 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 - Transmit Next Pointer" ] # [ inline ] pub fn txnptr ( & mut self ) -> _TXNPTRW { _TXNPTRW { w : self } } } } # [ doc = "Transmit Next Counter Register" ] pub struct TNCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transmit Next Counter Register" ] pub mod tncr { # [ 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 :: TNCR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 TXNCTRR { bits : u16 , } impl TXNCTRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _TXNCTRW < 'a > { w : & 'a mut W , } impl < 'a > _TXNCTRW < '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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & self ) -> TXNCTRR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; TXNCTRR { 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 - Transmit Counter Next" ] # [ inline ] pub fn txnctr ( & mut self ) -> _TXNCTRW { _TXNCTRW { w : self } } } } # [ doc = "Transfer Control Register" ] pub struct PTCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Control Register" ] pub mod ptcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PTCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & 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 _RXTENW < 'a > { w : & 'a mut W , } impl < 'a > _RXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _RXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTENW < 'a > { w : & 'a mut W , } impl < 'a > _TXTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TXTDISW < 'a > { w : & 'a mut W , } impl < 'a > _TXTDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & mut self ) -> _RXTENW { _RXTENW { w : self } } # [ doc = "Bit 1 - Receiver Transfer Disable" ] # [ inline ] pub fn rxtdis ( & mut self ) -> _RXTDISW { _RXTDISW { w : self } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & mut self ) -> _TXTENW { _TXTENW { w : self } } # [ doc = "Bit 9 - Transmitter Transfer Disable" ] # [ inline ] pub fn txtdis ( & mut self ) -> _TXTDISW { _TXTDISW { w : self } } } } # [ doc = "Transfer Status Register" ] pub struct PTSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Transfer Status Register" ] pub mod ptsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PTSR { # [ 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 RXTENR { bits : bool , } impl RXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TXTENR { bits : bool , } impl TXTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Receiver Transfer Enable" ] # [ inline ] pub fn rxten ( & self ) -> RXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RXTENR { bits } } # [ doc = "Bit 8 - Transmitter Transfer Enable" ] # [ inline ] pub fn txten ( & self ) -> TXTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TXTENR { bits } } } } } # [ doc = "Chip Identifier" ] pub struct CHIPID { _marker : PhantomData < * const ( ) > } unsafe impl Send for CHIPID { } impl CHIPID { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const chipid :: RegisterBlock { 0x400e_0940 as * const _ } } impl Deref for CHIPID { type Target = chipid :: RegisterBlock ; fn deref ( & self ) -> & chipid :: RegisterBlock { unsafe { & * CHIPID :: ptr ( ) } } } # [ doc = "Chip Identifier" ] pub mod chipid { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Chip ID Register" ] pub cidr : CIDR , # [ doc = "0x04 - Chip ID Extension Register" ] pub exid : EXID , } # [ doc = "Chip ID Register" ] pub struct CIDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Chip ID Register" ] pub mod cidr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: CIDR { # [ 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 VERSIONR { bits : u8 , } impl VERSIONR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `EPROC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum EPROCR { # [ doc = "ARM946ES" ] ARM946ES , # [ doc = "ARM7TDMI" ] ARM7TDMI , # [ doc = "Cortex-M3" ] CM3 , # [ doc = "ARM920T" ] ARM920T , # [ doc = "ARM926EJS" ] ARM926EJS , # [ doc = "Cortex-A5" ] CA5 , # [ doc = "Cortex-M4" ] CM4 , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl EPROCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { EPROCR :: ARM946ES => 0x01 , EPROCR :: ARM7TDMI => 0x02 , EPROCR :: CM3 => 0x03 , EPROCR :: ARM920T => 0x04 , EPROCR :: ARM926EJS => 0x05 , EPROCR :: CA5 => 0x06 , EPROCR :: CM4 => 0x07 , EPROCR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> EPROCR { match value { 1 => EPROCR :: ARM946ES , 2 => EPROCR :: ARM7TDMI , 3 => EPROCR :: CM3 , 4 => EPROCR :: ARM920T , 5 => EPROCR :: ARM926EJS , 6 => EPROCR :: CA5 , 7 => EPROCR :: CM4 , i => EPROCR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ARM946ES`" ] # [ inline ] pub fn is_arm946es ( & self ) -> bool { * self == EPROCR :: ARM946ES } # [ doc = "Checks if the value of the field is `ARM7TDMI`" ] # [ inline ] pub fn is_arm7tdmi ( & self ) -> bool { * self == EPROCR :: ARM7TDMI } # [ doc = "Checks if the value of the field is `CM3`" ] # [ inline ] pub fn is_cm3 ( & self ) -> bool { * self == EPROCR :: CM3 } # [ doc = "Checks if the value of the field is `ARM920T`" ] # [ inline ] pub fn is_arm920t ( & self ) -> bool { * self == EPROCR :: ARM920T } # [ doc = "Checks if the value of the field is `ARM926EJS`" ] # [ inline ] pub fn is_arm926ejs ( & self ) -> bool { * self == EPROCR :: ARM926EJS } # [ doc = "Checks if the value of the field is `CA5`" ] # [ inline ] pub fn is_ca5 ( & self ) -> bool { * self == EPROCR :: CA5 } # [ doc = "Checks if the value of the field is `CM4`" ] # [ inline ] pub fn is_cm4 ( & self ) -> bool { * self == EPROCR :: CM4 } } # [ doc = "Possible values of the field `NVPSIZ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NVPSIZR { # [ doc = "None" ] NONE , # [ doc = "8 Kbytes" ] _8K , # [ doc = "16 Kbytes" ] _16K , # [ doc = "32 Kbytes" ] _32K , # [ doc = "64 Kbytes" ] _64K , # [ doc = "128 Kbytes" ] _128K , # [ doc = "256 Kbytes" ] _256K , # [ doc = "512 Kbytes" ] _512K , # [ doc = "1024 Kbytes" ] _1024K , # [ doc = "2048 Kbytes" ] _2048K , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NVPSIZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NVPSIZR :: NONE => 0 , NVPSIZR :: _8K => 0x01 , NVPSIZR :: _16K => 0x02 , NVPSIZR :: _32K => 0x03 , NVPSIZR :: _64K => 0x05 , NVPSIZR :: _128K => 0x07 , NVPSIZR :: _256K => 0x09 , NVPSIZR :: _512K => 0x0a , NVPSIZR :: _1024K => 0x0c , NVPSIZR :: _2048K => 0x0e , NVPSIZR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NVPSIZR { match value { 0 => NVPSIZR :: NONE , 1 => NVPSIZR :: _8K , 2 => NVPSIZR :: _16K , 3 => NVPSIZR :: _32K , 5 => NVPSIZR :: _64K , 7 => NVPSIZR :: _128K , 9 => NVPSIZR :: _256K , 10 => NVPSIZR :: _512K , 12 => NVPSIZR :: _1024K , 14 => NVPSIZR :: _2048K , i => NVPSIZR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == NVPSIZR :: NONE } # [ doc = "Checks if the value of the field is `_8K`" ] # [ inline ] pub fn is_8k ( & self ) -> bool { * self == NVPSIZR :: _8K } # [ doc = "Checks if the value of the field is `_16K`" ] # [ inline ] pub fn is_16k ( & self ) -> bool { * self == NVPSIZR :: _16K } # [ doc = "Checks if the value of the field is `_32K`" ] # [ inline ] pub fn is_32k ( & self ) -> bool { * self == NVPSIZR :: _32K } # [ doc = "Checks if the value of the field is `_64K`" ] # [ inline ] pub fn is_64k ( & self ) -> bool { * self == NVPSIZR :: _64K } # [ doc = "Checks if the value of the field is `_128K`" ] # [ inline ] pub fn is_128k ( & self ) -> bool { * self == NVPSIZR :: _128K } # [ doc = "Checks if the value of the field is `_256K`" ] # [ inline ] pub fn is_256k ( & self ) -> bool { * self == NVPSIZR :: _256K } # [ doc = "Checks if the value of the field is `_512K`" ] # [ inline ] pub fn is_512k ( & self ) -> bool { * self == NVPSIZR :: _512K } # [ doc = "Checks if the value of the field is `_1024K`" ] # [ inline ] pub fn is_1024k ( & self ) -> bool { * self == NVPSIZR :: _1024K } # [ doc = "Checks if the value of the field is `_2048K`" ] # [ inline ] pub fn is_2048k ( & self ) -> bool { * self == NVPSIZR :: _2048K } } # [ doc = "Possible values of the field `NVPSIZ2`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NVPSIZ2R { # [ doc = "None" ] NONE , # [ doc = "8 Kbytes" ] _8K , # [ doc = "16 Kbytes" ] _16K , # [ doc = "32 Kbytes" ] _32K , # [ doc = "64 Kbytes" ] _64K , # [ doc = "128 Kbytes" ] _128K , # [ doc = "256 Kbytes" ] _256K , # [ doc = "512 Kbytes" ] _512K , # [ doc = "1024 Kbytes" ] _1024K , # [ doc = "2048 Kbytes" ] _2048K , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NVPSIZ2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NVPSIZ2R :: NONE => 0 , NVPSIZ2R :: _8K => 0x01 , NVPSIZ2R :: _16K => 0x02 , NVPSIZ2R :: _32K => 0x03 , NVPSIZ2R :: _64K => 0x05 , NVPSIZ2R :: _128K => 0x07 , NVPSIZ2R :: _256K => 0x09 , NVPSIZ2R :: _512K => 0x0a , NVPSIZ2R :: _1024K => 0x0c , NVPSIZ2R :: _2048K => 0x0e , NVPSIZ2R :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NVPSIZ2R { match value { 0 => NVPSIZ2R :: NONE , 1 => NVPSIZ2R :: _8K , 2 => NVPSIZ2R :: _16K , 3 => NVPSIZ2R :: _32K , 5 => NVPSIZ2R :: _64K , 7 => NVPSIZ2R :: _128K , 9 => NVPSIZ2R :: _256K , 10 => NVPSIZ2R :: _512K , 12 => NVPSIZ2R :: _1024K , 14 => NVPSIZ2R :: _2048K , i => NVPSIZ2R :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `NONE`" ] # [ inline ] pub fn is_none ( & self ) -> bool { * self == NVPSIZ2R :: NONE } # [ doc = "Checks if the value of the field is `_8K`" ] # [ inline ] pub fn is_8k ( & self ) -> bool { * self == NVPSIZ2R :: _8K } # [ doc = "Checks if the value of the field is `_16K`" ] # [ inline ] pub fn is_16k ( & self ) -> bool { * self == NVPSIZ2R :: _16K } # [ doc = "Checks if the value of the field is `_32K`" ] # [ inline ] pub fn is_32k ( & self ) -> bool { * self == NVPSIZ2R :: _32K } # [ doc = "Checks if the value of the field is `_64K`" ] # [ inline ] pub fn is_64k ( & self ) -> bool { * self == NVPSIZ2R :: _64K } # [ doc = "Checks if the value of the field is `_128K`" ] # [ inline ] pub fn is_128k ( & self ) -> bool { * self == NVPSIZ2R :: _128K } # [ doc = "Checks if the value of the field is `_256K`" ] # [ inline ] pub fn is_256k ( & self ) -> bool { * self == NVPSIZ2R :: _256K } # [ doc = "Checks if the value of the field is `_512K`" ] # [ inline ] pub fn is_512k ( & self ) -> bool { * self == NVPSIZ2R :: _512K } # [ doc = "Checks if the value of the field is `_1024K`" ] # [ inline ] pub fn is_1024k ( & self ) -> bool { * self == NVPSIZ2R :: _1024K } # [ doc = "Checks if the value of the field is `_2048K`" ] # [ inline ] pub fn is_2048k ( & self ) -> bool { * self == NVPSIZ2R :: _2048K } } # [ doc = "Possible values of the field `SRAMSIZ`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SRAMSIZR { # [ doc = "48 Kbytes" ] _48K , # [ doc = "192 Kbytes" ] _192K , # [ doc = "2 Kbytes" ] _2K , # [ doc = "6 Kbytes" ] _6K , # [ doc = "24 Kbytes" ] _24K , # [ doc = "4 Kbytes" ] _4K , # [ doc = "80 Kbytes" ] _80K , # [ doc = "160 Kbytes" ] _160K , # [ doc = "8 Kbytes" ] _8K , # [ doc = "16 Kbytes" ] _16K , # [ doc = "32 Kbytes" ] _32K , # [ doc = "64 Kbytes" ] _64K , # [ doc = "128 Kbytes" ] _128K , # [ doc = "256 Kbytes" ] _256K , # [ doc = "96 Kbytes" ] _96K , # [ doc = "512 Kbytes" ] _512K } impl SRAMSIZR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SRAMSIZR :: _48K => 0 , SRAMSIZR :: _192K => 0x01 , SRAMSIZR :: _2K => 0x02 , SRAMSIZR :: _6K => 0x03 , SRAMSIZR :: _24K => 0x04 , SRAMSIZR :: _4K => 0x05 , SRAMSIZR :: _80K => 0x06 , SRAMSIZR :: _160K => 0x07 , SRAMSIZR :: _8K => 0x08 , SRAMSIZR :: _16K => 0x09 , SRAMSIZR :: _32K => 0x0a , SRAMSIZR :: _64K => 0x0b , SRAMSIZR :: _128K => 0x0c , SRAMSIZR :: _256K => 0x0d , SRAMSIZR :: _96K => 0x0e , SRAMSIZR :: _512K => 0x0f } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SRAMSIZR { match value { 0 => SRAMSIZR :: _48K , 1 => SRAMSIZR :: _192K , 2 => SRAMSIZR :: _2K , 3 => SRAMSIZR :: _6K , 4 => SRAMSIZR :: _24K , 5 => SRAMSIZR :: _4K , 6 => SRAMSIZR :: _80K , 7 => SRAMSIZR :: _160K , 8 => SRAMSIZR :: _8K , 9 => SRAMSIZR :: _16K , 10 => SRAMSIZR :: _32K , 11 => SRAMSIZR :: _64K , 12 => SRAMSIZR :: _128K , 13 => SRAMSIZR :: _256K , 14 => SRAMSIZR :: _96K , 15 => SRAMSIZR :: _512K , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `_48K`" ] # [ inline ] pub fn is_48k ( & self ) -> bool { * self == SRAMSIZR :: _48K } # [ doc = "Checks if the value of the field is `_192K`" ] # [ inline ] pub fn is_192k ( & self ) -> bool { * self == SRAMSIZR :: _192K } # [ doc = "Checks if the value of the field is `_2K`" ] # [ inline ] pub fn is_2k ( & self ) -> bool { * self == SRAMSIZR :: _2K } # [ doc = "Checks if the value of the field is `_6K`" ] # [ inline ] pub fn is_6k ( & self ) -> bool { * self == SRAMSIZR :: _6K } # [ doc = "Checks if the value of the field is `_24K`" ] # [ inline ] pub fn is_24k ( & self ) -> bool { * self == SRAMSIZR :: _24K } # [ doc = "Checks if the value of the field is `_4K`" ] # [ inline ] pub fn is_4k ( & self ) -> bool { * self == SRAMSIZR :: _4K } # [ doc = "Checks if the value of the field is `_80K`" ] # [ inline ] pub fn is_80k ( & self ) -> bool { * self == SRAMSIZR :: _80K } # [ doc = "Checks if the value of the field is `_160K`" ] # [ inline ] pub fn is_160k ( & self ) -> bool { * self == SRAMSIZR :: _160K } # [ doc = "Checks if the value of the field is `_8K`" ] # [ inline ] pub fn is_8k ( & self ) -> bool { * self == SRAMSIZR :: _8K } # [ doc = "Checks if the value of the field is `_16K`" ] # [ inline ] pub fn is_16k ( & self ) -> bool { * self == SRAMSIZR :: _16K } # [ doc = "Checks if the value of the field is `_32K`" ] # [ inline ] pub fn is_32k ( & self ) -> bool { * self == SRAMSIZR :: _32K } # [ doc = "Checks if the value of the field is `_64K`" ] # [ inline ] pub fn is_64k ( & self ) -> bool { * self == SRAMSIZR :: _64K } # [ doc = "Checks if the value of the field is `_128K`" ] # [ inline ] pub fn is_128k ( & self ) -> bool { * self == SRAMSIZR :: _128K } # [ doc = "Checks if the value of the field is `_256K`" ] # [ inline ] pub fn is_256k ( & self ) -> bool { * self == SRAMSIZR :: _256K } # [ doc = "Checks if the value of the field is `_96K`" ] # [ inline ] pub fn is_96k ( & self ) -> bool { * self == SRAMSIZR :: _96K } # [ doc = "Checks if the value of the field is `_512K`" ] # [ inline ] pub fn is_512k ( & self ) -> bool { * self == SRAMSIZR :: _512K } } # [ doc = "Possible values of the field `ARCH`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ARCHR { # [ doc = "SAM3AxC (100-pin version)" ] SAM3AXC , # [ doc = "SAM3XxC (100-pin version)" ] SAM3XXC , # [ doc = "SAM3XxE (144-pin version)" ] SAM3XXE , # [ doc = "SAM3XxG (208/217-pin version)" ] SAM3XXG , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl ARCHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { ARCHR :: SAM3AXC => 0x83 , ARCHR :: SAM3XXC => 0x84 , ARCHR :: SAM3XXE => 0x85 , ARCHR :: SAM3XXG => 0x86 , ARCHR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> ARCHR { match value { 131 => ARCHR :: SAM3AXC , 132 => ARCHR :: SAM3XXC , 133 => ARCHR :: SAM3XXE , 134 => ARCHR :: SAM3XXG , i => ARCHR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SAM3AXC`" ] # [ inline ] pub fn is_sam3ax_c ( & self ) -> bool { * self == ARCHR :: SAM3AXC } # [ doc = "Checks if the value of the field is `SAM3XXC`" ] # [ inline ] pub fn is_sam3xx_c ( & self ) -> bool { * self == ARCHR :: SAM3XXC } # [ doc = "Checks if the value of the field is `SAM3XXE`" ] # [ inline ] pub fn is_sam3xx_e ( & self ) -> bool { * self == ARCHR :: SAM3XXE } # [ doc = "Checks if the value of the field is `SAM3XXG`" ] # [ inline ] pub fn is_sam3xx_g ( & self ) -> bool { * self == ARCHR :: SAM3XXG } } # [ doc = "Possible values of the field `NVPTYP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum NVPTYPR { # [ doc = "ROM" ] ROM , # [ doc = "ROMless or on-chip Flash" ] ROMLESS , # [ doc = "Embedded Flash Memory" ] FLASH , # [ doc = "ROM and Embedded Flash Memory- NVPSIZ is ROM size- NVPSIZ2 is Flash size" ] ROM_FLASH , # [ doc = "SRAM emulating ROM" ] SRAM , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl NVPTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { NVPTYPR :: ROM => 0 , NVPTYPR :: ROMLESS => 0x01 , NVPTYPR :: FLASH => 0x02 , NVPTYPR :: ROM_FLASH => 0x03 , NVPTYPR :: SRAM => 0x04 , NVPTYPR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> NVPTYPR { match value { 0 => NVPTYPR :: ROM , 1 => NVPTYPR :: ROMLESS , 2 => NVPTYPR :: FLASH , 3 => NVPTYPR :: ROM_FLASH , 4 => NVPTYPR :: SRAM , i => NVPTYPR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `ROM`" ] # [ inline ] pub fn is_rom ( & self ) -> bool { * self == NVPTYPR :: ROM } # [ doc = "Checks if the value of the field is `ROMLESS`" ] # [ inline ] pub fn is_romless ( & self ) -> bool { * self == NVPTYPR :: ROMLESS } # [ doc = "Checks if the value of the field is `FLASH`" ] # [ inline ] pub fn is_flash ( & self ) -> bool { * self == NVPTYPR :: FLASH } # [ doc = "Checks if the value of the field is `ROM_FLASH`" ] # [ inline ] pub fn is_rom_flash ( & self ) -> bool { * self == NVPTYPR :: ROM_FLASH } # [ doc = "Checks if the value of the field is `SRAM`" ] # [ inline ] pub fn is_sram ( & self ) -> bool { * self == NVPTYPR :: SRAM } } # [ doc = r" Value of the field" ] pub struct EXTR { bits : bool , } impl EXTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 0:4 - Version of the Device" ] # [ inline ] pub fn version ( & self ) -> VERSIONR { let bits = { const MASK : u8 = 0x1f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; VERSIONR { bits } } # [ doc = "Bits 5:7 - Embedded Processor" ] # [ inline ] pub fn eproc ( & self ) -> EPROCR { EPROCR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 8:11 - Nonvolatile Program Memory Size" ] # [ inline ] pub fn nvpsiz ( & self ) -> NVPSIZR { NVPSIZR :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:15 - Second Nonvolatile Program Memory Size" ] # [ inline ] pub fn nvpsiz2 ( & self ) -> NVPSIZ2R { NVPSIZ2R :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 16:19 - Internal SRAM Size" ] # [ inline ] pub fn sramsiz ( & self ) -> SRAMSIZR { SRAMSIZR :: _from ( { const MASK : u8 = 0x0f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 20:27 - Architecture Identifier" ] # [ inline ] pub fn arch ( & self ) -> ARCHR { ARCHR :: _from ( { const MASK : u8 = 0xff ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 28:30 - Nonvolatile Program Memory Type" ] # [ inline ] pub fn nvptyp ( & self ) -> NVPTYPR { NVPTYPR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 31 - Extension Flag" ] # [ inline ] pub fn ext ( & self ) -> EXTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; EXTR { bits } } } } # [ doc = "Chip ID Extension Register" ] pub struct EXID { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Chip ID Extension Register" ] pub mod exid { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: EXID { # [ 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 EXIDR { bits : u32 , } impl EXIDR { # [ 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 - Chip ID Extension" ] # [ inline ] pub fn exid ( & self ) -> EXIDR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; EXIDR { bits } } } } } # [ doc = "Embedded Flash Controller 0" ] pub struct EFC0 { _marker : PhantomData < * const ( ) > } unsafe impl Send for EFC0 { } impl EFC0 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const efc0 :: RegisterBlock { 0x400e_0a00 as * const _ } } impl Deref for EFC0 { type Target = efc0 :: RegisterBlock ; fn deref ( & self ) -> & efc0 :: RegisterBlock { unsafe { & * EFC0 :: ptr ( ) } } } # [ doc = "Embedded Flash Controller 0" ] pub mod efc0 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - EEFC Flash Mode Register" ] pub fmr : FMR , # [ doc = "0x04 - EEFC Flash Command Register" ] pub fcr : FCR , # [ doc = "0x08 - EEFC Flash Status Register" ] pub fsr : FSR , # [ doc = "0x0c - EEFC Flash Result Register" ] pub frr : FRR , } # [ doc = "EEFC Flash Mode Register" ] pub struct FMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Mode Register" ] pub mod fmr { # [ 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 :: FMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FRDYR { bits : bool , } impl FRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FWSR { bits : u8 , } impl FWSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct SCODR { bits : bool , } impl SCODR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FAMR { bits : bool , } impl FAMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _FRDYW < 'a > { w : & 'a mut W , } impl < 'a > _FRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FWSW < 'a > { w : & 'a mut W , } impl < 'a > _FWSW < '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 _SCODW < 'a > { w : & 'a mut W , } impl < 'a > _SCODW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FAMW < 'a > { w : & 'a mut W , } impl < 'a > _FAMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Ready Interrupt Enable" ] # [ inline ] pub fn frdy ( & self ) -> FRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRDYR { bits } } # [ doc = "Bits 8:11 - Flash Wait State" ] # [ inline ] pub fn fws ( & self ) -> FWSR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FWSR { bits } } # [ doc = "Bit 16 - Sequential Code Optimization Disable" ] # [ inline ] pub fn scod ( & self ) -> SCODR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCODR { bits } } # [ doc = "Bit 24 - Flash Access Mode" ] # [ inline ] pub fn fam ( & self ) -> FAMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FAMR { 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 - Ready Interrupt Enable" ] # [ inline ] pub fn frdy ( & mut self ) -> _FRDYW { _FRDYW { w : self } } # [ doc = "Bits 8:11 - Flash Wait State" ] # [ inline ] pub fn fws ( & mut self ) -> _FWSW { _FWSW { w : self } } # [ doc = "Bit 16 - Sequential Code Optimization Disable" ] # [ inline ] pub fn scod ( & mut self ) -> _SCODW { _SCODW { w : self } } # [ doc = "Bit 24 - Flash Access Mode" ] # [ inline ] pub fn fam ( & mut self ) -> _FAMW { _FAMW { w : self } } } } # [ doc = "EEFC Flash Command Register" ] pub struct FCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Command Register" ] pub mod fcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: FCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = "Values that can be written to the field `FCMD`" ] pub enum FCMDW { # [ doc = "Get Flash Descriptor" ] GETD , # [ doc = "Write page" ] WP , # [ doc = "Write page and lock" ] WPL , # [ doc = "Erase page and write page" ] EWP , # [ doc = "Erase page and write page then lock" ] EWPL , # [ doc = "Erase all" ] EA , # [ doc = "Set Lock Bit" ] SLB , # [ doc = "Clear Lock Bit" ] CLB , # [ doc = "Get Lock Bit" ] GLB , # [ doc = "Set GPNVM Bit" ] SGPB , # [ doc = "Clear GPNVM Bit" ] CGPB , # [ doc = "Get GPNVM Bit" ] GGPB , # [ doc = "Start Read Unique Identifier" ] STUI , # [ doc = "Stop Read Unique Identifier" ] SPUI , # [ doc = "Get CALIB Bit" ] GCALB } impl FCMDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCMDW :: GETD => 0 , FCMDW :: WP => 1 , FCMDW :: WPL => 2 , FCMDW :: EWP => 3 , FCMDW :: EWPL => 4 , FCMDW :: EA => 5 , FCMDW :: SLB => 8 , FCMDW :: CLB => 9 , FCMDW :: GLB => 10 , FCMDW :: SGPB => 11 , FCMDW :: CGPB => 12 , FCMDW :: GGPB => 13 , FCMDW :: STUI => 14 , FCMDW :: SPUI => 15 , FCMDW :: GCALB => 16 } } } # [ doc = r" Proxy" ] pub struct _FCMDW < 'a > { w : & 'a mut W , } impl < 'a > _FCMDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCMDW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Get Flash Descriptor" ] # [ inline ] pub fn getd ( self ) -> & 'a mut W { self . variant ( FCMDW :: GETD ) } # [ doc = "Write page" ] # [ inline ] pub fn wp ( self ) -> & 'a mut W { self . variant ( FCMDW :: WP ) } # [ doc = "Write page and lock" ] # [ inline ] pub fn wpl ( self ) -> & 'a mut W { self . variant ( FCMDW :: WPL ) } # [ doc = "Erase page and write page" ] # [ inline ] pub fn ewp ( self ) -> & 'a mut W { self . variant ( FCMDW :: EWP ) } # [ doc = "Erase page and write page then lock" ] # [ inline ] pub fn ewpl ( self ) -> & 'a mut W { self . variant ( FCMDW :: EWPL ) } # [ doc = "Erase all" ] # [ inline ] pub fn ea ( self ) -> & 'a mut W { self . variant ( FCMDW :: EA ) } # [ doc = "Set Lock Bit" ] # [ inline ] pub fn slb ( self ) -> & 'a mut W { self . variant ( FCMDW :: SLB ) } # [ doc = "Clear Lock Bit" ] # [ inline ] pub fn clb ( self ) -> & 'a mut W { self . variant ( FCMDW :: CLB ) } # [ doc = "Get Lock Bit" ] # [ inline ] pub fn glb ( self ) -> & 'a mut W { self . variant ( FCMDW :: GLB ) } # [ doc = "Set GPNVM Bit" ] # [ inline ] pub fn sgpb ( self ) -> & 'a mut W { self . variant ( FCMDW :: SGPB ) } # [ doc = "Clear GPNVM Bit" ] # [ inline ] pub fn cgpb ( self ) -> & 'a mut W { self . variant ( FCMDW :: CGPB ) } # [ doc = "Get GPNVM Bit" ] # [ inline ] pub fn ggpb ( self ) -> & 'a mut W { self . variant ( FCMDW :: GGPB ) } # [ doc = "Start Read Unique Identifier" ] # [ inline ] pub fn stui ( self ) -> & 'a mut W { self . variant ( FCMDW :: STUI ) } # [ doc = "Stop Read Unique Identifier" ] # [ inline ] pub fn spui ( self ) -> & 'a mut W { self . variant ( FCMDW :: SPUI ) } # [ doc = "Get CALIB Bit" ] # [ inline ] pub fn gcalb ( self ) -> & 'a mut W { self . variant ( FCMDW :: GCALB ) } # [ 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 _FARGW < 'a > { w : & 'a mut W , } impl < 'a > _FARGW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `FKEY`" ] pub enum FKEYW { # [ doc = "The 0x5A value enables the command defined by the bits of the register. If the field is written with a different value, the write is not performed and no action is started." ] PASSWD } impl FKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FKEYW :: PASSWD => 90 } } } # [ doc = r" Proxy" ] pub struct _FKEYW < 'a > { w : & 'a mut W , } impl < 'a > _FKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The 0x5A value enables the command defined by the bits of the register. If the field is written with a different value, the write is not performed and no action is started." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( FKEYW :: PASSWD ) } # [ 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 } } impl W { # [ doc = "Bits 0:7 - Flash Command" ] # [ inline ] pub fn fcmd ( & mut self ) -> _FCMDW { _FCMDW { w : self } } # [ doc = "Bits 8:23 - Flash Command Argument" ] # [ inline ] pub fn farg ( & mut self ) -> _FARGW { _FARGW { w : self } } # [ doc = "Bits 24:31 - Flash Writing Protection Key" ] # [ inline ] pub fn fkey ( & mut self ) -> _FKEYW { _FKEYW { w : self } } } } # [ doc = "EEFC Flash Status Register" ] pub struct FSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Status Register" ] pub mod fsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FSR { # [ 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 FRDYR { bits : bool , } impl FRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCMDER { bits : bool , } impl FCMDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FLOCKER { bits : bool , } impl FLOCKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Flash Ready Status" ] # [ inline ] pub fn frdy ( & self ) -> FRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRDYR { bits } } # [ doc = "Bit 1 - Flash Command Error Status" ] # [ inline ] pub fn fcmde ( & self ) -> FCMDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCMDER { bits } } # [ doc = "Bit 2 - Flash Lock Error Status" ] # [ inline ] pub fn flocke ( & self ) -> FLOCKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FLOCKER { bits } } } } # [ doc = "EEFC Flash Result Register" ] pub struct FRR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Result Register" ] pub mod frr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FRR { # [ 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 FVALUER { bits : u32 , } impl FVALUER { # [ 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 - Flash Result Value" ] # [ inline ] pub fn fvalue ( & self ) -> FVALUER { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; FVALUER { bits } } } } } # [ doc = "Embedded Flash Controller 1" ] pub struct EFC1 { _marker : PhantomData < * const ( ) > } unsafe impl Send for EFC1 { } impl EFC1 { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const efc1 :: RegisterBlock { 0x400e_0c00 as * const _ } } impl Deref for EFC1 { type Target = efc1 :: RegisterBlock ; fn deref ( & self ) -> & efc1 :: RegisterBlock { unsafe { & * EFC1 :: ptr ( ) } } } # [ doc = "Embedded Flash Controller 1" ] pub mod efc1 { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - EEFC Flash Mode Register" ] pub fmr : FMR , # [ doc = "0x04 - EEFC Flash Command Register" ] pub fcr : FCR , # [ doc = "0x08 - EEFC Flash Status Register" ] pub fsr : FSR , # [ doc = "0x0c - EEFC Flash Result Register" ] pub frr : FRR , } # [ doc = "EEFC Flash Mode Register" ] pub struct FMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Mode Register" ] pub mod fmr { # [ 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 :: FMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 FRDYR { bits : bool , } impl FRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FWSR { bits : u8 , } impl FWSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct SCODR { bits : bool , } impl SCODR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FAMR { bits : bool , } impl FAMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _FRDYW < 'a > { w : & 'a mut W , } impl < 'a > _FRDYW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FWSW < 'a > { w : & 'a mut W , } impl < 'a > _FWSW < '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 _SCODW < 'a > { w : & 'a mut W , } impl < 'a > _SCODW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _FAMW < 'a > { w : & 'a mut W , } impl < 'a > _FAMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Ready Interrupt Enable" ] # [ inline ] pub fn frdy ( & self ) -> FRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRDYR { bits } } # [ doc = "Bits 8:11 - Flash Wait State" ] # [ inline ] pub fn fws ( & self ) -> FWSR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; FWSR { bits } } # [ doc = "Bit 16 - Sequential Code Optimization Disable" ] # [ inline ] pub fn scod ( & self ) -> SCODR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SCODR { bits } } # [ doc = "Bit 24 - Flash Access Mode" ] # [ inline ] pub fn fam ( & self ) -> FAMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FAMR { 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 - Ready Interrupt Enable" ] # [ inline ] pub fn frdy ( & mut self ) -> _FRDYW { _FRDYW { w : self } } # [ doc = "Bits 8:11 - Flash Wait State" ] # [ inline ] pub fn fws ( & mut self ) -> _FWSW { _FWSW { w : self } } # [ doc = "Bit 16 - Sequential Code Optimization Disable" ] # [ inline ] pub fn scod ( & mut self ) -> _SCODW { _SCODW { w : self } } # [ doc = "Bit 24 - Flash Access Mode" ] # [ inline ] pub fn fam ( & mut self ) -> _FAMW { _FAMW { w : self } } } } # [ doc = "EEFC Flash Command Register" ] pub struct FCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Command Register" ] pub mod fcr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: FCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = "Values that can be written to the field `FCMD`" ] pub enum FCMDW { # [ doc = "Get Flash Descriptor" ] GETD , # [ doc = "Write page" ] WP , # [ doc = "Write page and lock" ] WPL , # [ doc = "Erase page and write page" ] EWP , # [ doc = "Erase page and write page then lock" ] EWPL , # [ doc = "Erase all" ] EA , # [ doc = "Set Lock Bit" ] SLB , # [ doc = "Clear Lock Bit" ] CLB , # [ doc = "Get Lock Bit" ] GLB , # [ doc = "Set GPNVM Bit" ] SGPB , # [ doc = "Clear GPNVM Bit" ] CGPB , # [ doc = "Get GPNVM Bit" ] GGPB , # [ doc = "Start Read Unique Identifier" ] STUI , # [ doc = "Stop Read Unique Identifier" ] SPUI , # [ doc = "Get CALIB Bit" ] GCALB } impl FCMDW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FCMDW :: GETD => 0 , FCMDW :: WP => 1 , FCMDW :: WPL => 2 , FCMDW :: EWP => 3 , FCMDW :: EWPL => 4 , FCMDW :: EA => 5 , FCMDW :: SLB => 8 , FCMDW :: CLB => 9 , FCMDW :: GLB => 10 , FCMDW :: SGPB => 11 , FCMDW :: CGPB => 12 , FCMDW :: GGPB => 13 , FCMDW :: STUI => 14 , FCMDW :: SPUI => 15 , FCMDW :: GCALB => 16 } } } # [ doc = r" Proxy" ] pub struct _FCMDW < 'a > { w : & 'a mut W , } impl < 'a > _FCMDW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FCMDW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Get Flash Descriptor" ] # [ inline ] pub fn getd ( self ) -> & 'a mut W { self . variant ( FCMDW :: GETD ) } # [ doc = "Write page" ] # [ inline ] pub fn wp ( self ) -> & 'a mut W { self . variant ( FCMDW :: WP ) } # [ doc = "Write page and lock" ] # [ inline ] pub fn wpl ( self ) -> & 'a mut W { self . variant ( FCMDW :: WPL ) } # [ doc = "Erase page and write page" ] # [ inline ] pub fn ewp ( self ) -> & 'a mut W { self . variant ( FCMDW :: EWP ) } # [ doc = "Erase page and write page then lock" ] # [ inline ] pub fn ewpl ( self ) -> & 'a mut W { self . variant ( FCMDW :: EWPL ) } # [ doc = "Erase all" ] # [ inline ] pub fn ea ( self ) -> & 'a mut W { self . variant ( FCMDW :: EA ) } # [ doc = "Set Lock Bit" ] # [ inline ] pub fn slb ( self ) -> & 'a mut W { self . variant ( FCMDW :: SLB ) } # [ doc = "Clear Lock Bit" ] # [ inline ] pub fn clb ( self ) -> & 'a mut W { self . variant ( FCMDW :: CLB ) } # [ doc = "Get Lock Bit" ] # [ inline ] pub fn glb ( self ) -> & 'a mut W { self . variant ( FCMDW :: GLB ) } # [ doc = "Set GPNVM Bit" ] # [ inline ] pub fn sgpb ( self ) -> & 'a mut W { self . variant ( FCMDW :: SGPB ) } # [ doc = "Clear GPNVM Bit" ] # [ inline ] pub fn cgpb ( self ) -> & 'a mut W { self . variant ( FCMDW :: CGPB ) } # [ doc = "Get GPNVM Bit" ] # [ inline ] pub fn ggpb ( self ) -> & 'a mut W { self . variant ( FCMDW :: GGPB ) } # [ doc = "Start Read Unique Identifier" ] # [ inline ] pub fn stui ( self ) -> & 'a mut W { self . variant ( FCMDW :: STUI ) } # [ doc = "Stop Read Unique Identifier" ] # [ inline ] pub fn spui ( self ) -> & 'a mut W { self . variant ( FCMDW :: SPUI ) } # [ doc = "Get CALIB Bit" ] # [ inline ] pub fn gcalb ( self ) -> & 'a mut W { self . variant ( FCMDW :: GCALB ) } # [ 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 _FARGW < 'a > { w : & 'a mut W , } impl < 'a > _FARGW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = "Values that can be written to the field `FKEY`" ] pub enum FKEYW { # [ doc = "The 0x5A value enables the command defined by the bits of the register. If the field is written with a different value, the write is not performed and no action is started." ] PASSWD } impl FKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FKEYW :: PASSWD => 90 } } } # [ doc = r" Proxy" ] pub struct _FKEYW < 'a > { w : & 'a mut W , } impl < 'a > _FKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "The 0x5A value enables the command defined by the bits of the register. If the field is written with a different value, the write is not performed and no action is started." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( FKEYW :: PASSWD ) } # [ 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 } } impl W { # [ doc = "Bits 0:7 - Flash Command" ] # [ inline ] pub fn fcmd ( & mut self ) -> _FCMDW { _FCMDW { w : self } } # [ doc = "Bits 8:23 - Flash Command Argument" ] # [ inline ] pub fn farg ( & mut self ) -> _FARGW { _FARGW { w : self } } # [ doc = "Bits 24:31 - Flash Writing Protection Key" ] # [ inline ] pub fn fkey ( & mut self ) -> _FKEYW { _FKEYW { w : self } } } } # [ doc = "EEFC Flash Status Register" ] pub struct FSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Status Register" ] pub mod fsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FSR { # [ 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 FRDYR { bits : bool , } impl FRDYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FCMDER { bits : bool , } impl FCMDER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct FLOCKER { bits : bool , } impl FLOCKER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Flash Ready Status" ] # [ inline ] pub fn frdy ( & self ) -> FRDYR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FRDYR { bits } } # [ doc = "Bit 1 - Flash Command Error Status" ] # [ inline ] pub fn fcmde ( & self ) -> FCMDER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FCMDER { bits } } # [ doc = "Bit 2 - Flash Lock Error Status" ] # [ inline ] pub fn flocke ( & self ) -> FLOCKER { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; FLOCKER { bits } } } } # [ doc = "EEFC Flash Result Register" ] pub struct FRR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "EEFC Flash Result Register" ] pub mod frr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FRR { # [ 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 FVALUER { bits : u32 , } impl FVALUER { # [ 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 - Flash Result Value" ] # [ inline ] pub fn fvalue ( & self ) -> FVALUER { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; FVALUER { bits } } } } } # [ doc = "Parallel Input/Output Controller A" ] pub struct PIOA { _marker : PhantomData < * const ( ) > } unsafe impl Send for PIOA { } impl PIOA { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const pioa :: RegisterBlock { 0x400e_0e00 as * const _ } } impl Deref for PIOA { type Target = pioa :: RegisterBlock ; fn deref ( & self ) -> & pioa :: RegisterBlock { unsafe { & * PIOA :: ptr ( ) } } } # [ doc = "Parallel Input/Output Controller A" ] pub mod pioa { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - PIO Enable Register" ] pub per : PER , # [ doc = "0x04 - PIO Disable Register" ] pub pdr : PDR , # [ doc = "0x08 - PIO Status Register" ] pub psr : PSR , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Output Enable Register" ] pub oer : OER , # [ doc = "0x14 - Output Disable Register" ] pub odr : ODR , # [ doc = "0x18 - Output Status Register" ] pub osr : OSR , _reserved6 : [ u8 ; 4usize ] , # [ doc = "0x20 - Glitch Input Filter Enable Register" ] pub ifer : IFER , # [ doc = "0x24 - Glitch Input Filter Disable Register" ] pub ifdr : IFDR , # [ doc = "0x28 - Glitch Input Filter Status Register" ] pub ifsr : IFSR , _reserved9 : [ u8 ; 4usize ] , # [ doc = "0x30 - Set Output Data Register" ] pub sodr : SODR , # [ doc = "0x34 - Clear Output Data Register" ] pub codr : CODR , # [ doc = "0x38 - Output Data Status Register" ] pub odsr : ODSR , # [ doc = "0x3c - Pin Data Status Register" ] pub pdsr : PDSR , # [ doc = "0x40 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x44 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x48 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x4c - Interrupt Status Register" ] pub isr : ISR , # [ doc = "0x50 - Multi-driver Enable Register" ] pub mder : MDER , # [ doc = "0x54 - Multi-driver Disable Register" ] pub mddr : MDDR , # [ doc = "0x58 - Multi-driver Status Register" ] pub mdsr : MDSR , _reserved20 : [ u8 ; 4usize ] , # [ doc = "0x60 - Pull-up Disable Register" ] pub pudr : PUDR , # [ doc = "0x64 - Pull-up Enable Register" ] pub puer : PUER , # [ doc = "0x68 - Pad Pull-up Status Register" ] pub pusr : PUSR , _reserved23 : [ u8 ; 4usize ] , # [ doc = "0x70 - Peripheral AB Select Register" ] pub absr : ABSR , _reserved24 : [ u8 ; 12usize ] , # [ doc = "0x80 - System Clock Glitch Input Filter Select Register" ] pub scifsr : SCIFSR , # [ doc = "0x84 - Debouncing Input Filter Select Register" ] pub difsr : DIFSR , # [ doc = "0x88 - Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub ifdgsr : IFDGSR , # [ doc = "0x8c - Slow Clock Divider Debouncing Register" ] pub scdr : SCDR , _reserved28 : [ u8 ; 16usize ] , # [ doc = "0xa0 - Output Write Enable" ] pub ower : OWER , # [ doc = "0xa4 - Output Write Disable" ] pub owdr : OWDR , # [ doc = "0xa8 - Output Write Status Register" ] pub owsr : OWSR , _reserved31 : [ u8 ; 4usize ] , # [ doc = "0xb0 - Additional Interrupt Modes Enable Register" ] pub aimer : AIMER , # [ doc = "0xb4 - Additional Interrupt Modes Disables Register" ] pub aimdr : AIMDR , # [ doc = "0xb8 - Additional Interrupt Modes Mask Register" ] pub aimmr : AIMMR , _reserved34 : [ u8 ; 4usize ] , # [ doc = "0xc0 - Edge Select Register" ] pub esr : ESR , # [ doc = "0xc4 - Level Select Register" ] pub lsr : LSR , # [ doc = "0xc8 - Edge/Level Status Register" ] pub elsr : ELSR , _reserved37 : [ u8 ; 4usize ] , # [ doc = "0xd0 - Falling Edge/Low Level Select Register" ] pub fellsr : FELLSR , # [ doc = "0xd4 - Rising Edge/ High Level Select Register" ] pub rehlsr : REHLSR , # [ doc = "0xd8 - Fall/Rise - Low/High Status Register" ] pub frlhsr : FRLHSR , _reserved40 : [ u8 ; 4usize ] , # [ doc = "0xe0 - Lock Status" ] pub locksr : LOCKSR , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , } # [ doc = "PIO Enable Register" ] pub struct PER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Enable Register" ] pub mod per { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Disable Register" ] pub struct PDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Disable Register" ] pub mod pdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Status Register" ] pub struct PSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Status Register" ] pub mod psr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - PIO Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - PIO Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - PIO Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - PIO Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - PIO Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - PIO Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - PIO Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - PIO Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - PIO Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - PIO Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - PIO Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - PIO Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - PIO Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - PIO Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - PIO Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - PIO Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - PIO Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - PIO Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - PIO Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - PIO Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - PIO Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - PIO Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - PIO Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - PIO Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - PIO Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - PIO Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - PIO Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - PIO Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - PIO Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - PIO Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - PIO Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - PIO Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Output Enable Register" ] pub struct OER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Enable Register" ] pub mod oer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Disable Register" ] pub struct ODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Disable Register" ] pub mod odr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Status Register" ] pub struct OSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Status Register" ] pub mod osr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Glitch Input Filter Enable Register" ] pub struct IFER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Enable Register" ] pub mod ifer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Disable Register" ] pub struct IFDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Disable Register" ] pub mod ifdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Status Register" ] pub struct IFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Status Register" ] pub mod ifsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Filer Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Filer Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Filer Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Filer Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Filer Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Filer Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Filer Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Filer Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Filer Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Filer Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Filer Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Filer Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Filer Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Filer Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Filer Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Filer Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Filer Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Filer Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Filer Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Filer Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Filer Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Filer Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Filer Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Filer Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Filer Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Filer Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Filer Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Filer Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Filer Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Filer Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Filer Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Filer Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Set Output Data Register" ] pub struct SODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Set Output Data Register" ] pub mod sodr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Set Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Set Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Set Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Set Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Set Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Set Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Set Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Set Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Set Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Set Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Set Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Set Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Set Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Set Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Set Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Set Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Set Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Set Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Set Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Set Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Set Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Set Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Set Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Set Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Set Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Set Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Set Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Set Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Set Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Set Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Set Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Set Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Clear Output Data Register" ] pub struct CODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Clear Output Data Register" ] pub mod codr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Clear Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Clear Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Clear Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Clear Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Clear Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Clear Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Clear Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Clear Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Clear Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Clear Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Clear Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Clear Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Clear Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Clear Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Clear Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Clear Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Clear Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Clear Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Clear Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Clear Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Clear Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Clear Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Clear Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Clear Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Clear Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Clear Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Clear Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Clear Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Clear Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Clear Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Clear Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Clear Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Data Status Register" ] pub struct ODSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Data Status Register" ] pub mod odsr { # [ 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 :: ODSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } impl W { # [ doc = "Bit 0 - Output Data Status" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pin Data Status Register" ] pub struct PDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pin Data Status Register" ] pub mod pdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Mask" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Mask" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Mask" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Mask" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Mask" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Mask" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Mask" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Mask" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Mask" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Mask" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Mask" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Mask" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Mask" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Mask" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Mask" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Mask" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Mask" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Mask" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Mask" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Mask" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Mask" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Mask" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Mask" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Mask" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Mask" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Mask" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Mask" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Mask" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Mask" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Mask" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Mask" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Mask" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Multi-driver Enable Register" ] pub struct MDER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Enable Register" ] pub mod mder { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Disable Register" ] pub struct MDDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Disable Register" ] pub mod mddr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Status Register" ] pub struct MDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Status Register" ] pub mod mdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Multi Drive Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Multi Drive Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Multi Drive Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Multi Drive Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Multi Drive Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Multi Drive Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Multi Drive Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Multi Drive Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Multi Drive Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Multi Drive Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Multi Drive Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Multi Drive Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Multi Drive Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Multi Drive Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Multi Drive Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Multi Drive Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Multi Drive Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Multi Drive Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Multi Drive Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Multi Drive Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Multi Drive Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Multi Drive Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Multi Drive Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Multi Drive Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Multi Drive Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Multi Drive Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Multi Drive Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Multi Drive Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Multi Drive Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Multi Drive Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Multi Drive Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Multi Drive Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Pull-up Disable Register" ] pub struct PUDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Disable Register" ] pub mod pudr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pull-up Enable Register" ] pub struct PUER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Enable Register" ] pub mod puer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pad Pull-up Status Register" ] pub struct PUSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pad Pull-up Status Register" ] pub mod pusr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PUSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Pull Up Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Pull Up Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Pull Up Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Pull Up Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Pull Up Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Pull Up Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Pull Up Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Pull Up Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Pull Up Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Pull Up Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Pull Up Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Pull Up Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Pull Up Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Pull Up Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Pull Up Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Pull Up Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Pull Up Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Pull Up Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Pull Up Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Pull Up Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Pull Up Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Pull Up Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Pull Up Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Pull Up Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Pull Up Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Pull Up Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Pull Up Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Pull Up Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Pull Up Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Pull Up Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Pull Up Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Pull Up Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Peripheral AB Select Register" ] pub struct ABSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral AB Select Register" ] pub mod absr { # [ 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 :: ABSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Peripheral A Select." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { 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 A Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub struct SCIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub mod scifsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SCIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Debouncing Input Filter Select Register" ] pub struct DIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Debouncing Input Filter Select Register" ] pub mod difsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Debouncing Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Debouncing Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Debouncing Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Debouncing Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Debouncing Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Debouncing Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Debouncing Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Debouncing Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Debouncing Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Debouncing Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Debouncing Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Debouncing Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Debouncing Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Debouncing Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Debouncing Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Debouncing Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Debouncing Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Debouncing Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Debouncing Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Debouncing Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Debouncing Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Debouncing Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Debouncing Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Debouncing Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Debouncing Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Debouncing Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Debouncing Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Debouncing Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Debouncing Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Debouncing Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Debouncing Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Debouncing Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub struct IFDGSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub mod ifdgsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFDGSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Slow Clock Divider Debouncing Register" ] pub struct SCDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Slow Clock Divider Debouncing Register" ] pub mod scdr { # [ 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 :: SCDR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DIVR { bits : u16 , } impl DIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DIVW < 'a > { w : & 'a mut W , } impl < 'a > _DIVW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x3fff ; 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & self ) -> DIVR { let bits = { const MASK : u16 = 0x3fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DIVR { 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & mut self ) -> _DIVW { _DIVW { w : self } } } } # [ doc = "Output Write Enable" ] pub struct OWER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Enable" ] pub mod ower { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Disable" ] pub struct OWDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Disable" ] pub mod owdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Status Register" ] pub struct OWSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Status Register" ] pub mod owsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OWSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Write Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Write Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Write Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Write Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Write Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Write Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Write Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Write Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Write Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Write Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Write Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Write Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Write Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Write Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Write Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Write Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Write Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Write Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Write Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Write Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Write Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Write Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Write Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Write Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Write Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Write Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Write Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Write Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Write Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Write Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Write Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Write Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Additional Interrupt Modes Enable Register" ] pub struct AIMER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Enable Register" ] pub mod aimer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Disables Register" ] pub struct AIMDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Disables Register" ] pub mod aimdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Mask Register" ] pub struct AIMMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Mask Register" ] pub mod aimmr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: AIMMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Peripheral CD Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral CD Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral CD Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral CD Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral CD Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral CD Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral CD Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral CD Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral CD Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral CD Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral CD Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral CD Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral CD Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral CD Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral CD Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral CD Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral CD Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral CD Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral CD Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral CD Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral CD Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral CD Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral CD Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral CD Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral CD Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral CD Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral CD Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral CD Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral CD Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral CD Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral CD Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral CD Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Edge Select Register" ] pub struct ESR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge Select Register" ] pub mod esr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ESR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Edge Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Edge Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Edge Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Edge Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Edge Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Edge Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Edge Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Edge Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Edge Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Edge Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Edge Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Edge Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Edge Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Edge Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Edge Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Edge Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Edge Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Edge Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Edge Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Edge Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Edge Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Edge Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Edge Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Edge Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Edge Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Edge Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Edge Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Edge Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Edge Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Edge Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Edge Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Edge Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Level Select Register" ] pub struct LSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Level Select Register" ] pub mod lsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: LSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Edge/Level Status Register" ] pub struct ELSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge/Level Status Register" ] pub mod elsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ELSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Falling Edge/Low Level Select Register" ] pub struct FELLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Falling Edge/Low Level Select Register" ] pub mod fellsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: FELLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Rising Edge/ High Level Select Register" ] pub struct REHLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Rising Edge/ High Level Select Register" ] pub mod rehlsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: REHLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Fall/Rise - Low/High Status Register" ] pub struct FRLHSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fall/Rise - Low/High Status Register" ] pub mod frlhsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FRLHSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Lock Status" ] pub struct LOCKSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Lock Status" ] pub mod locksr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LOCKSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Lock Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Lock Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Lock Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Lock Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Lock Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Lock Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Lock Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Lock Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Lock Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Lock Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Lock Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Lock Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Lock Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Lock Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Lock Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Lock Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Lock Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Lock Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Lock Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Lock Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Lock Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Lock Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Lock Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Lock Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Lock Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Lock Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Lock Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Lock Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Lock Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Lock Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Lock Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Lock Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } } # [ doc = "Parallel Input/Output Controller B" ] pub struct PIOB { _marker : PhantomData < * const ( ) > } unsafe impl Send for PIOB { } impl PIOB { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const piob :: RegisterBlock { 0x400e_1000 as * const _ } } impl Deref for PIOB { type Target = piob :: RegisterBlock ; fn deref ( & self ) -> & piob :: RegisterBlock { unsafe { & * PIOB :: ptr ( ) } } } # [ doc = "Parallel Input/Output Controller B" ] pub mod piob { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - PIO Enable Register" ] pub per : PER , # [ doc = "0x04 - PIO Disable Register" ] pub pdr : PDR , # [ doc = "0x08 - PIO Status Register" ] pub psr : PSR , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Output Enable Register" ] pub oer : OER , # [ doc = "0x14 - Output Disable Register" ] pub odr : ODR , # [ doc = "0x18 - Output Status Register" ] pub osr : OSR , _reserved6 : [ u8 ; 4usize ] , # [ doc = "0x20 - Glitch Input Filter Enable Register" ] pub ifer : IFER , # [ doc = "0x24 - Glitch Input Filter Disable Register" ] pub ifdr : IFDR , # [ doc = "0x28 - Glitch Input Filter Status Register" ] pub ifsr : IFSR , _reserved9 : [ u8 ; 4usize ] , # [ doc = "0x30 - Set Output Data Register" ] pub sodr : SODR , # [ doc = "0x34 - Clear Output Data Register" ] pub codr : CODR , # [ doc = "0x38 - Output Data Status Register" ] pub odsr : ODSR , # [ doc = "0x3c - Pin Data Status Register" ] pub pdsr : PDSR , # [ doc = "0x40 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x44 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x48 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x4c - Interrupt Status Register" ] pub isr : ISR , # [ doc = "0x50 - Multi-driver Enable Register" ] pub mder : MDER , # [ doc = "0x54 - Multi-driver Disable Register" ] pub mddr : MDDR , # [ doc = "0x58 - Multi-driver Status Register" ] pub mdsr : MDSR , _reserved20 : [ u8 ; 4usize ] , # [ doc = "0x60 - Pull-up Disable Register" ] pub pudr : PUDR , # [ doc = "0x64 - Pull-up Enable Register" ] pub puer : PUER , # [ doc = "0x68 - Pad Pull-up Status Register" ] pub pusr : PUSR , _reserved23 : [ u8 ; 4usize ] , # [ doc = "0x70 - Peripheral AB Select Register" ] pub absr : ABSR , _reserved24 : [ u8 ; 12usize ] , # [ doc = "0x80 - System Clock Glitch Input Filter Select Register" ] pub scifsr : SCIFSR , # [ doc = "0x84 - Debouncing Input Filter Select Register" ] pub difsr : DIFSR , # [ doc = "0x88 - Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub ifdgsr : IFDGSR , # [ doc = "0x8c - Slow Clock Divider Debouncing Register" ] pub scdr : SCDR , _reserved28 : [ u8 ; 16usize ] , # [ doc = "0xa0 - Output Write Enable" ] pub ower : OWER , # [ doc = "0xa4 - Output Write Disable" ] pub owdr : OWDR , # [ doc = "0xa8 - Output Write Status Register" ] pub owsr : OWSR , _reserved31 : [ u8 ; 4usize ] , # [ doc = "0xb0 - Additional Interrupt Modes Enable Register" ] pub aimer : AIMER , # [ doc = "0xb4 - Additional Interrupt Modes Disables Register" ] pub aimdr : AIMDR , # [ doc = "0xb8 - Additional Interrupt Modes Mask Register" ] pub aimmr : AIMMR , _reserved34 : [ u8 ; 4usize ] , # [ doc = "0xc0 - Edge Select Register" ] pub esr : ESR , # [ doc = "0xc4 - Level Select Register" ] pub lsr : LSR , # [ doc = "0xc8 - Edge/Level Status Register" ] pub elsr : ELSR , _reserved37 : [ u8 ; 4usize ] , # [ doc = "0xd0 - Falling Edge/Low Level Select Register" ] pub fellsr : FELLSR , # [ doc = "0xd4 - Rising Edge/ High Level Select Register" ] pub rehlsr : REHLSR , # [ doc = "0xd8 - Fall/Rise - Low/High Status Register" ] pub frlhsr : FRLHSR , _reserved40 : [ u8 ; 4usize ] , # [ doc = "0xe0 - Lock Status" ] pub locksr : LOCKSR , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , } # [ doc = "PIO Enable Register" ] pub struct PER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Enable Register" ] pub mod per { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Disable Register" ] pub struct PDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Disable Register" ] pub mod pdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Status Register" ] pub struct PSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Status Register" ] pub mod psr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - PIO Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - PIO Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - PIO Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - PIO Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - PIO Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - PIO Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - PIO Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - PIO Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - PIO Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - PIO Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - PIO Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - PIO Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - PIO Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - PIO Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - PIO Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - PIO Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - PIO Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - PIO Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - PIO Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - PIO Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - PIO Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - PIO Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - PIO Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - PIO Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - PIO Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - PIO Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - PIO Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - PIO Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - PIO Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - PIO Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - PIO Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - PIO Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Output Enable Register" ] pub struct OER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Enable Register" ] pub mod oer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Disable Register" ] pub struct ODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Disable Register" ] pub mod odr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Status Register" ] pub struct OSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Status Register" ] pub mod osr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Glitch Input Filter Enable Register" ] pub struct IFER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Enable Register" ] pub mod ifer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Disable Register" ] pub struct IFDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Disable Register" ] pub mod ifdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Status Register" ] pub struct IFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Status Register" ] pub mod ifsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Filer Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Filer Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Filer Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Filer Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Filer Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Filer Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Filer Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Filer Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Filer Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Filer Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Filer Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Filer Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Filer Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Filer Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Filer Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Filer Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Filer Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Filer Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Filer Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Filer Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Filer Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Filer Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Filer Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Filer Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Filer Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Filer Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Filer Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Filer Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Filer Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Filer Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Filer Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Filer Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Set Output Data Register" ] pub struct SODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Set Output Data Register" ] pub mod sodr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Set Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Set Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Set Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Set Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Set Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Set Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Set Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Set Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Set Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Set Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Set Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Set Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Set Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Set Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Set Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Set Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Set Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Set Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Set Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Set Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Set Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Set Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Set Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Set Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Set Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Set Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Set Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Set Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Set Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Set Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Set Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Set Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Clear Output Data Register" ] pub struct CODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Clear Output Data Register" ] pub mod codr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Clear Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Clear Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Clear Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Clear Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Clear Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Clear Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Clear Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Clear Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Clear Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Clear Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Clear Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Clear Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Clear Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Clear Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Clear Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Clear Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Clear Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Clear Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Clear Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Clear Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Clear Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Clear Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Clear Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Clear Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Clear Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Clear Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Clear Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Clear Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Clear Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Clear Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Clear Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Clear Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Data Status Register" ] pub struct ODSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Data Status Register" ] pub mod odsr { # [ 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 :: ODSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } impl W { # [ doc = "Bit 0 - Output Data Status" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pin Data Status Register" ] pub struct PDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pin Data Status Register" ] pub mod pdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Mask" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Mask" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Mask" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Mask" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Mask" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Mask" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Mask" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Mask" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Mask" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Mask" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Mask" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Mask" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Mask" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Mask" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Mask" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Mask" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Mask" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Mask" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Mask" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Mask" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Mask" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Mask" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Mask" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Mask" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Mask" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Mask" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Mask" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Mask" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Mask" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Mask" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Mask" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Mask" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Multi-driver Enable Register" ] pub struct MDER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Enable Register" ] pub mod mder { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Disable Register" ] pub struct MDDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Disable Register" ] pub mod mddr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Status Register" ] pub struct MDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Status Register" ] pub mod mdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Multi Drive Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Multi Drive Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Multi Drive Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Multi Drive Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Multi Drive Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Multi Drive Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Multi Drive Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Multi Drive Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Multi Drive Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Multi Drive Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Multi Drive Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Multi Drive Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Multi Drive Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Multi Drive Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Multi Drive Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Multi Drive Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Multi Drive Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Multi Drive Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Multi Drive Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Multi Drive Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Multi Drive Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Multi Drive Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Multi Drive Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Multi Drive Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Multi Drive Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Multi Drive Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Multi Drive Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Multi Drive Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Multi Drive Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Multi Drive Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Multi Drive Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Multi Drive Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Pull-up Disable Register" ] pub struct PUDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Disable Register" ] pub mod pudr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pull-up Enable Register" ] pub struct PUER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Enable Register" ] pub mod puer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pad Pull-up Status Register" ] pub struct PUSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pad Pull-up Status Register" ] pub mod pusr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PUSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Pull Up Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Pull Up Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Pull Up Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Pull Up Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Pull Up Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Pull Up Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Pull Up Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Pull Up Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Pull Up Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Pull Up Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Pull Up Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Pull Up Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Pull Up Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Pull Up Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Pull Up Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Pull Up Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Pull Up Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Pull Up Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Pull Up Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Pull Up Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Pull Up Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Pull Up Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Pull Up Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Pull Up Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Pull Up Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Pull Up Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Pull Up Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Pull Up Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Pull Up Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Pull Up Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Pull Up Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Pull Up Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Peripheral AB Select Register" ] pub struct ABSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral AB Select Register" ] pub mod absr { # [ 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 :: ABSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Peripheral A Select." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { 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 A Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub struct SCIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub mod scifsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SCIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Debouncing Input Filter Select Register" ] pub struct DIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Debouncing Input Filter Select Register" ] pub mod difsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Debouncing Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Debouncing Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Debouncing Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Debouncing Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Debouncing Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Debouncing Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Debouncing Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Debouncing Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Debouncing Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Debouncing Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Debouncing Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Debouncing Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Debouncing Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Debouncing Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Debouncing Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Debouncing Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Debouncing Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Debouncing Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Debouncing Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Debouncing Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Debouncing Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Debouncing Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Debouncing Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Debouncing Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Debouncing Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Debouncing Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Debouncing Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Debouncing Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Debouncing Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Debouncing Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Debouncing Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Debouncing Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub struct IFDGSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub mod ifdgsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFDGSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Slow Clock Divider Debouncing Register" ] pub struct SCDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Slow Clock Divider Debouncing Register" ] pub mod scdr { # [ 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 :: SCDR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DIVR { bits : u16 , } impl DIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DIVW < 'a > { w : & 'a mut W , } impl < 'a > _DIVW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x3fff ; 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & self ) -> DIVR { let bits = { const MASK : u16 = 0x3fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DIVR { 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & mut self ) -> _DIVW { _DIVW { w : self } } } } # [ doc = "Output Write Enable" ] pub struct OWER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Enable" ] pub mod ower { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Disable" ] pub struct OWDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Disable" ] pub mod owdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Status Register" ] pub struct OWSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Status Register" ] pub mod owsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OWSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Write Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Write Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Write Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Write Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Write Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Write Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Write Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Write Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Write Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Write Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Write Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Write Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Write Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Write Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Write Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Write Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Write Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Write Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Write Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Write Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Write Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Write Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Write Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Write Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Write Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Write Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Write Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Write Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Write Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Write Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Write Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Write Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Additional Interrupt Modes Enable Register" ] pub struct AIMER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Enable Register" ] pub mod aimer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Disables Register" ] pub struct AIMDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Disables Register" ] pub mod aimdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Mask Register" ] pub struct AIMMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Mask Register" ] pub mod aimmr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: AIMMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Peripheral CD Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral CD Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral CD Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral CD Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral CD Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral CD Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral CD Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral CD Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral CD Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral CD Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral CD Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral CD Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral CD Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral CD Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral CD Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral CD Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral CD Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral CD Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral CD Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral CD Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral CD Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral CD Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral CD Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral CD Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral CD Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral CD Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral CD Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral CD Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral CD Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral CD Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral CD Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral CD Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Edge Select Register" ] pub struct ESR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge Select Register" ] pub mod esr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ESR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Edge Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Edge Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Edge Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Edge Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Edge Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Edge Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Edge Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Edge Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Edge Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Edge Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Edge Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Edge Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Edge Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Edge Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Edge Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Edge Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Edge Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Edge Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Edge Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Edge Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Edge Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Edge Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Edge Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Edge Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Edge Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Edge Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Edge Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Edge Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Edge Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Edge Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Edge Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Edge Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Level Select Register" ] pub struct LSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Level Select Register" ] pub mod lsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: LSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Edge/Level Status Register" ] pub struct ELSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge/Level Status Register" ] pub mod elsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ELSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Falling Edge/Low Level Select Register" ] pub struct FELLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Falling Edge/Low Level Select Register" ] pub mod fellsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: FELLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Rising Edge/ High Level Select Register" ] pub struct REHLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Rising Edge/ High Level Select Register" ] pub mod rehlsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: REHLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Fall/Rise - Low/High Status Register" ] pub struct FRLHSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fall/Rise - Low/High Status Register" ] pub mod frlhsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FRLHSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Lock Status" ] pub struct LOCKSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Lock Status" ] pub mod locksr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LOCKSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Lock Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Lock Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Lock Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Lock Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Lock Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Lock Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Lock Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Lock Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Lock Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Lock Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Lock Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Lock Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Lock Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Lock Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Lock Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Lock Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Lock Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Lock Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Lock Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Lock Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Lock Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Lock Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Lock Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Lock Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Lock Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Lock Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Lock Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Lock Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Lock Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Lock Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Lock Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Lock Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } } # [ doc = "Parallel Input/Output Controller C" ] pub struct PIOC { _marker : PhantomData < * const ( ) > } unsafe impl Send for PIOC { } impl PIOC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const pioc :: RegisterBlock { 0x400e_1200 as * const _ } } impl Deref for PIOC { type Target = pioc :: RegisterBlock ; fn deref ( & self ) -> & pioc :: RegisterBlock { unsafe { & * PIOC :: ptr ( ) } } } # [ doc = "Parallel Input/Output Controller C" ] pub mod pioc { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - PIO Enable Register" ] pub per : PER , # [ doc = "0x04 - PIO Disable Register" ] pub pdr : PDR , # [ doc = "0x08 - PIO Status Register" ] pub psr : PSR , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Output Enable Register" ] pub oer : OER , # [ doc = "0x14 - Output Disable Register" ] pub odr : ODR , # [ doc = "0x18 - Output Status Register" ] pub osr : OSR , _reserved6 : [ u8 ; 4usize ] , # [ doc = "0x20 - Glitch Input Filter Enable Register" ] pub ifer : IFER , # [ doc = "0x24 - Glitch Input Filter Disable Register" ] pub ifdr : IFDR , # [ doc = "0x28 - Glitch Input Filter Status Register" ] pub ifsr : IFSR , _reserved9 : [ u8 ; 4usize ] , # [ doc = "0x30 - Set Output Data Register" ] pub sodr : SODR , # [ doc = "0x34 - Clear Output Data Register" ] pub codr : CODR , # [ doc = "0x38 - Output Data Status Register" ] pub odsr : ODSR , # [ doc = "0x3c - Pin Data Status Register" ] pub pdsr : PDSR , # [ doc = "0x40 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x44 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x48 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x4c - Interrupt Status Register" ] pub isr : ISR , # [ doc = "0x50 - Multi-driver Enable Register" ] pub mder : MDER , # [ doc = "0x54 - Multi-driver Disable Register" ] pub mddr : MDDR , # [ doc = "0x58 - Multi-driver Status Register" ] pub mdsr : MDSR , _reserved20 : [ u8 ; 4usize ] , # [ doc = "0x60 - Pull-up Disable Register" ] pub pudr : PUDR , # [ doc = "0x64 - Pull-up Enable Register" ] pub puer : PUER , # [ doc = "0x68 - Pad Pull-up Status Register" ] pub pusr : PUSR , _reserved23 : [ u8 ; 4usize ] , # [ doc = "0x70 - Peripheral AB Select Register" ] pub absr : ABSR , _reserved24 : [ u8 ; 12usize ] , # [ doc = "0x80 - System Clock Glitch Input Filter Select Register" ] pub scifsr : SCIFSR , # [ doc = "0x84 - Debouncing Input Filter Select Register" ] pub difsr : DIFSR , # [ doc = "0x88 - Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub ifdgsr : IFDGSR , # [ doc = "0x8c - Slow Clock Divider Debouncing Register" ] pub scdr : SCDR , _reserved28 : [ u8 ; 16usize ] , # [ doc = "0xa0 - Output Write Enable" ] pub ower : OWER , # [ doc = "0xa4 - Output Write Disable" ] pub owdr : OWDR , # [ doc = "0xa8 - Output Write Status Register" ] pub owsr : OWSR , _reserved31 : [ u8 ; 4usize ] , # [ doc = "0xb0 - Additional Interrupt Modes Enable Register" ] pub aimer : AIMER , # [ doc = "0xb4 - Additional Interrupt Modes Disables Register" ] pub aimdr : AIMDR , # [ doc = "0xb8 - Additional Interrupt Modes Mask Register" ] pub aimmr : AIMMR , _reserved34 : [ u8 ; 4usize ] , # [ doc = "0xc0 - Edge Select Register" ] pub esr : ESR , # [ doc = "0xc4 - Level Select Register" ] pub lsr : LSR , # [ doc = "0xc8 - Edge/Level Status Register" ] pub elsr : ELSR , _reserved37 : [ u8 ; 4usize ] , # [ doc = "0xd0 - Falling Edge/Low Level Select Register" ] pub fellsr : FELLSR , # [ doc = "0xd4 - Rising Edge/ High Level Select Register" ] pub rehlsr : REHLSR , # [ doc = "0xd8 - Fall/Rise - Low/High Status Register" ] pub frlhsr : FRLHSR , _reserved40 : [ u8 ; 4usize ] , # [ doc = "0xe0 - Lock Status" ] pub locksr : LOCKSR , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , } # [ doc = "PIO Enable Register" ] pub struct PER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Enable Register" ] pub mod per { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Disable Register" ] pub struct PDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Disable Register" ] pub mod pdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Status Register" ] pub struct PSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Status Register" ] pub mod psr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - PIO Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - PIO Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - PIO Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - PIO Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - PIO Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - PIO Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - PIO Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - PIO Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - PIO Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - PIO Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - PIO Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - PIO Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - PIO Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - PIO Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - PIO Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - PIO Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - PIO Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - PIO Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - PIO Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - PIO Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - PIO Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - PIO Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - PIO Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - PIO Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - PIO Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - PIO Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - PIO Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - PIO Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - PIO Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - PIO Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - PIO Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - PIO Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Output Enable Register" ] pub struct OER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Enable Register" ] pub mod oer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Disable Register" ] pub struct ODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Disable Register" ] pub mod odr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Status Register" ] pub struct OSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Status Register" ] pub mod osr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Glitch Input Filter Enable Register" ] pub struct IFER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Enable Register" ] pub mod ifer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Disable Register" ] pub struct IFDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Disable Register" ] pub mod ifdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Status Register" ] pub struct IFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Status Register" ] pub mod ifsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Filer Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Filer Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Filer Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Filer Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Filer Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Filer Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Filer Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Filer Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Filer Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Filer Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Filer Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Filer Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Filer Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Filer Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Filer Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Filer Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Filer Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Filer Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Filer Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Filer Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Filer Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Filer Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Filer Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Filer Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Filer Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Filer Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Filer Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Filer Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Filer Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Filer Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Filer Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Filer Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Set Output Data Register" ] pub struct SODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Set Output Data Register" ] pub mod sodr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Set Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Set Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Set Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Set Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Set Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Set Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Set Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Set Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Set Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Set Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Set Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Set Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Set Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Set Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Set Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Set Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Set Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Set Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Set Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Set Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Set Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Set Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Set Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Set Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Set Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Set Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Set Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Set Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Set Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Set Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Set Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Set Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Clear Output Data Register" ] pub struct CODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Clear Output Data Register" ] pub mod codr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Clear Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Clear Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Clear Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Clear Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Clear Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Clear Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Clear Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Clear Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Clear Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Clear Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Clear Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Clear Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Clear Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Clear Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Clear Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Clear Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Clear Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Clear Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Clear Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Clear Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Clear Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Clear Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Clear Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Clear Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Clear Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Clear Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Clear Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Clear Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Clear Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Clear Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Clear Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Clear Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Data Status Register" ] pub struct ODSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Data Status Register" ] pub mod odsr { # [ 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 :: ODSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } impl W { # [ doc = "Bit 0 - Output Data Status" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pin Data Status Register" ] pub struct PDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pin Data Status Register" ] pub mod pdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Mask" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Mask" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Mask" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Mask" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Mask" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Mask" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Mask" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Mask" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Mask" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Mask" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Mask" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Mask" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Mask" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Mask" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Mask" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Mask" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Mask" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Mask" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Mask" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Mask" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Mask" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Mask" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Mask" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Mask" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Mask" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Mask" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Mask" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Mask" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Mask" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Mask" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Mask" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Mask" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Multi-driver Enable Register" ] pub struct MDER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Enable Register" ] pub mod mder { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Disable Register" ] pub struct MDDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Disable Register" ] pub mod mddr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Status Register" ] pub struct MDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Status Register" ] pub mod mdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Multi Drive Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Multi Drive Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Multi Drive Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Multi Drive Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Multi Drive Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Multi Drive Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Multi Drive Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Multi Drive Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Multi Drive Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Multi Drive Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Multi Drive Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Multi Drive Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Multi Drive Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Multi Drive Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Multi Drive Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Multi Drive Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Multi Drive Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Multi Drive Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Multi Drive Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Multi Drive Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Multi Drive Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Multi Drive Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Multi Drive Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Multi Drive Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Multi Drive Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Multi Drive Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Multi Drive Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Multi Drive Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Multi Drive Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Multi Drive Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Multi Drive Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Multi Drive Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Pull-up Disable Register" ] pub struct PUDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Disable Register" ] pub mod pudr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pull-up Enable Register" ] pub struct PUER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Enable Register" ] pub mod puer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pad Pull-up Status Register" ] pub struct PUSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pad Pull-up Status Register" ] pub mod pusr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PUSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Pull Up Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Pull Up Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Pull Up Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Pull Up Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Pull Up Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Pull Up Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Pull Up Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Pull Up Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Pull Up Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Pull Up Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Pull Up Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Pull Up Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Pull Up Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Pull Up Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Pull Up Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Pull Up Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Pull Up Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Pull Up Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Pull Up Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Pull Up Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Pull Up Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Pull Up Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Pull Up Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Pull Up Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Pull Up Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Pull Up Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Pull Up Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Pull Up Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Pull Up Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Pull Up Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Pull Up Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Pull Up Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Peripheral AB Select Register" ] pub struct ABSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral AB Select Register" ] pub mod absr { # [ 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 :: ABSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Peripheral A Select." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { 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 A Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub struct SCIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub mod scifsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SCIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Debouncing Input Filter Select Register" ] pub struct DIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Debouncing Input Filter Select Register" ] pub mod difsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Debouncing Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Debouncing Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Debouncing Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Debouncing Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Debouncing Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Debouncing Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Debouncing Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Debouncing Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Debouncing Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Debouncing Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Debouncing Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Debouncing Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Debouncing Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Debouncing Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Debouncing Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Debouncing Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Debouncing Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Debouncing Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Debouncing Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Debouncing Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Debouncing Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Debouncing Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Debouncing Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Debouncing Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Debouncing Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Debouncing Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Debouncing Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Debouncing Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Debouncing Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Debouncing Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Debouncing Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Debouncing Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub struct IFDGSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub mod ifdgsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFDGSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Slow Clock Divider Debouncing Register" ] pub struct SCDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Slow Clock Divider Debouncing Register" ] pub mod scdr { # [ 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 :: SCDR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DIVR { bits : u16 , } impl DIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DIVW < 'a > { w : & 'a mut W , } impl < 'a > _DIVW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x3fff ; 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & self ) -> DIVR { let bits = { const MASK : u16 = 0x3fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DIVR { 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & mut self ) -> _DIVW { _DIVW { w : self } } } } # [ doc = "Output Write Enable" ] pub struct OWER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Enable" ] pub mod ower { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Disable" ] pub struct OWDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Disable" ] pub mod owdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Status Register" ] pub struct OWSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Status Register" ] pub mod owsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OWSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Write Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Write Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Write Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Write Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Write Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Write Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Write Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Write Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Write Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Write Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Write Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Write Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Write Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Write Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Write Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Write Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Write Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Write Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Write Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Write Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Write Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Write Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Write Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Write Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Write Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Write Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Write Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Write Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Write Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Write Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Write Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Write Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Additional Interrupt Modes Enable Register" ] pub struct AIMER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Enable Register" ] pub mod aimer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Disables Register" ] pub struct AIMDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Disables Register" ] pub mod aimdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Mask Register" ] pub struct AIMMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Mask Register" ] pub mod aimmr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: AIMMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Peripheral CD Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral CD Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral CD Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral CD Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral CD Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral CD Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral CD Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral CD Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral CD Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral CD Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral CD Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral CD Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral CD Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral CD Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral CD Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral CD Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral CD Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral CD Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral CD Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral CD Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral CD Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral CD Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral CD Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral CD Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral CD Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral CD Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral CD Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral CD Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral CD Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral CD Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral CD Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral CD Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Edge Select Register" ] pub struct ESR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge Select Register" ] pub mod esr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ESR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Edge Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Edge Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Edge Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Edge Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Edge Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Edge Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Edge Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Edge Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Edge Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Edge Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Edge Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Edge Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Edge Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Edge Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Edge Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Edge Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Edge Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Edge Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Edge Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Edge Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Edge Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Edge Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Edge Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Edge Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Edge Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Edge Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Edge Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Edge Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Edge Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Edge Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Edge Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Edge Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Level Select Register" ] pub struct LSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Level Select Register" ] pub mod lsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: LSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Edge/Level Status Register" ] pub struct ELSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge/Level Status Register" ] pub mod elsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ELSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Falling Edge/Low Level Select Register" ] pub struct FELLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Falling Edge/Low Level Select Register" ] pub mod fellsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: FELLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Rising Edge/ High Level Select Register" ] pub struct REHLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Rising Edge/ High Level Select Register" ] pub mod rehlsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: REHLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Fall/Rise - Low/High Status Register" ] pub struct FRLHSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fall/Rise - Low/High Status Register" ] pub mod frlhsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FRLHSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Lock Status" ] pub struct LOCKSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Lock Status" ] pub mod locksr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LOCKSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Lock Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Lock Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Lock Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Lock Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Lock Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Lock Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Lock Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Lock Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Lock Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Lock Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Lock Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Lock Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Lock Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Lock Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Lock Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Lock Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Lock Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Lock Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Lock Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Lock Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Lock Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Lock Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Lock Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Lock Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Lock Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Lock Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Lock Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Lock Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Lock Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Lock Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Lock Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Lock Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } } # [ doc = "Parallel Input/Output Controller D" ] pub struct PIOD { _marker : PhantomData < * const ( ) > } unsafe impl Send for PIOD { } impl PIOD { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const piod :: RegisterBlock { 0x400e_1400 as * const _ } } impl Deref for PIOD { type Target = piod :: RegisterBlock ; fn deref ( & self ) -> & piod :: RegisterBlock { unsafe { & * PIOD :: ptr ( ) } } } # [ doc = "Parallel Input/Output Controller D" ] pub mod piod { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - PIO Enable Register" ] pub per : PER , # [ doc = "0x04 - PIO Disable Register" ] pub pdr : PDR , # [ doc = "0x08 - PIO Status Register" ] pub psr : PSR , _reserved3 : [ u8 ; 4usize ] , # [ doc = "0x10 - Output Enable Register" ] pub oer : OER , # [ doc = "0x14 - Output Disable Register" ] pub odr : ODR , # [ doc = "0x18 - Output Status Register" ] pub osr : OSR , _reserved6 : [ u8 ; 4usize ] , # [ doc = "0x20 - Glitch Input Filter Enable Register" ] pub ifer : IFER , # [ doc = "0x24 - Glitch Input Filter Disable Register" ] pub ifdr : IFDR , # [ doc = "0x28 - Glitch Input Filter Status Register" ] pub ifsr : IFSR , _reserved9 : [ u8 ; 4usize ] , # [ doc = "0x30 - Set Output Data Register" ] pub sodr : SODR , # [ doc = "0x34 - Clear Output Data Register" ] pub codr : CODR , # [ doc = "0x38 - Output Data Status Register" ] pub odsr : ODSR , # [ doc = "0x3c - Pin Data Status Register" ] pub pdsr : PDSR , # [ doc = "0x40 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x44 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x48 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x4c - Interrupt Status Register" ] pub isr : ISR , # [ doc = "0x50 - Multi-driver Enable Register" ] pub mder : MDER , # [ doc = "0x54 - Multi-driver Disable Register" ] pub mddr : MDDR , # [ doc = "0x58 - Multi-driver Status Register" ] pub mdsr : MDSR , _reserved20 : [ u8 ; 4usize ] , # [ doc = "0x60 - Pull-up Disable Register" ] pub pudr : PUDR , # [ doc = "0x64 - Pull-up Enable Register" ] pub puer : PUER , # [ doc = "0x68 - Pad Pull-up Status Register" ] pub pusr : PUSR , _reserved23 : [ u8 ; 4usize ] , # [ doc = "0x70 - Peripheral AB Select Register" ] pub absr : ABSR , _reserved24 : [ u8 ; 12usize ] , # [ doc = "0x80 - System Clock Glitch Input Filter Select Register" ] pub scifsr : SCIFSR , # [ doc = "0x84 - Debouncing Input Filter Select Register" ] pub difsr : DIFSR , # [ doc = "0x88 - Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub ifdgsr : IFDGSR , # [ doc = "0x8c - Slow Clock Divider Debouncing Register" ] pub scdr : SCDR , _reserved28 : [ u8 ; 16usize ] , # [ doc = "0xa0 - Output Write Enable" ] pub ower : OWER , # [ doc = "0xa4 - Output Write Disable" ] pub owdr : OWDR , # [ doc = "0xa8 - Output Write Status Register" ] pub owsr : OWSR , _reserved31 : [ u8 ; 4usize ] , # [ doc = "0xb0 - Additional Interrupt Modes Enable Register" ] pub aimer : AIMER , # [ doc = "0xb4 - Additional Interrupt Modes Disables Register" ] pub aimdr : AIMDR , # [ doc = "0xb8 - Additional Interrupt Modes Mask Register" ] pub aimmr : AIMMR , _reserved34 : [ u8 ; 4usize ] , # [ doc = "0xc0 - Edge Select Register" ] pub esr : ESR , # [ doc = "0xc4 - Level Select Register" ] pub lsr : LSR , # [ doc = "0xc8 - Edge/Level Status Register" ] pub elsr : ELSR , _reserved37 : [ u8 ; 4usize ] , # [ doc = "0xd0 - Falling Edge/Low Level Select Register" ] pub fellsr : FELLSR , # [ doc = "0xd4 - Rising Edge/ High Level Select Register" ] pub rehlsr : REHLSR , # [ doc = "0xd8 - Fall/Rise - Low/High Status Register" ] pub frlhsr : FRLHSR , _reserved40 : [ u8 ; 4usize ] , # [ doc = "0xe0 - Lock Status" ] pub locksr : LOCKSR , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , # [ doc = "0xe8 - Write Protect Status Register" ] pub wpsr : WPSR , } # [ doc = "PIO Enable Register" ] pub struct PER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Enable Register" ] pub mod per { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Disable Register" ] pub struct PDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Disable Register" ] pub mod pdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - PIO Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - PIO Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - PIO Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - PIO Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - PIO Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - PIO Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - PIO Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - PIO Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - PIO Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - PIO Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - PIO Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - PIO Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - PIO Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - PIO Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - PIO Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - PIO Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - PIO Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - PIO Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - PIO Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - PIO Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - PIO Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - PIO Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - PIO Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - PIO Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - PIO Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - PIO Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - PIO Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - PIO Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - PIO Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - PIO Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - PIO Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - PIO Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "PIO Status Register" ] pub struct PSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "PIO Status Register" ] pub mod psr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - PIO Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - PIO Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - PIO Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - PIO Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - PIO Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - PIO Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - PIO Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - PIO Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - PIO Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - PIO Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - PIO Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - PIO Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - PIO Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - PIO Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - PIO Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - PIO Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - PIO Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - PIO Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - PIO Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - PIO Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - PIO Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - PIO Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - PIO Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - PIO Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - PIO Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - PIO Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - PIO Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - PIO Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - PIO Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - PIO Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - PIO Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - PIO Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Output Enable Register" ] pub struct OER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Enable Register" ] pub mod oer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Disable Register" ] pub struct ODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Disable Register" ] pub mod odr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Status Register" ] pub struct OSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Status Register" ] pub mod osr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Glitch Input Filter Enable Register" ] pub struct IFER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Enable Register" ] pub mod ifer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Disable Register" ] pub struct IFDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Disable Register" ] pub mod ifdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IFDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Filter Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Filter Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Filter Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Filter Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Filter Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Filter Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Filter Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Filter Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Filter Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Filter Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Filter Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Filter Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Filter Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Filter Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Filter Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Filter Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Filter Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Filter Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Filter Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Filter Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Filter Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Filter Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Filter Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Filter Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Filter Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Filter Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Filter Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Filter Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Filter Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Filter Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Filter Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Filter Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch Input Filter Status Register" ] pub struct IFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch Input Filter Status Register" ] pub mod ifsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Filer Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Filer Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Filer Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Filer Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Filer Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Filer Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Filer Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Filer Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Filer Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Filer Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Filer Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Filer Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Filer Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Filer Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Filer Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Filer Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Filer Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Filer Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Filer Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Filer Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Filer Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Filer Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Filer Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Filer Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Filer Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Filer Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Filer Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Filer Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Filer Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Filer Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Filer Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Filer Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Set Output Data Register" ] pub struct SODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Set Output Data Register" ] pub mod sodr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Set Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Set Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Set Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Set Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Set Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Set Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Set Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Set Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Set Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Set Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Set Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Set Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Set Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Set Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Set Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Set Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Set Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Set Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Set Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Set Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Set Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Set Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Set Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Set Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Set Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Set Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Set Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Set Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Set Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Set Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Set Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Set Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Clear Output Data Register" ] pub struct CODR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Clear Output Data Register" ] pub mod codr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CODR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Clear Output Data" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Clear Output Data" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Clear Output Data" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Clear Output Data" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Clear Output Data" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Clear Output Data" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Clear Output Data" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Clear Output Data" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Clear Output Data" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Clear Output Data" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Clear Output Data" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Clear Output Data" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Clear Output Data" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Clear Output Data" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Clear Output Data" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Clear Output Data" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Clear Output Data" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Clear Output Data" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Clear Output Data" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Clear Output Data" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Clear Output Data" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Clear Output Data" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Clear Output Data" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Clear Output Data" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Clear Output Data" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Clear Output Data" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Clear Output Data" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Clear Output Data" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Clear Output Data" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Clear Output Data" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Clear Output Data" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Clear Output Data" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Data Status Register" ] pub struct ODSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Data Status Register" ] pub mod odsr { # [ 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 :: ODSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } impl W { # [ doc = "Bit 0 - Output Data Status" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pin Data Status Register" ] pub struct PDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pin Data Status Register" ] pub mod pdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Data Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Data Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Data Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Data Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Data Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Data Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Data Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Data Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Data Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Data Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Data Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Data Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Data Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Data Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Data Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Data Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Data Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Data Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Data Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Data Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Data Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Data Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Data Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Data Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Data Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Data Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Data Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Data Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Data Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Data Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Data Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Data Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Enable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Enable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Enable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Enable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Enable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Enable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Enable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Enable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Enable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Enable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Enable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Enable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Enable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Enable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Enable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Enable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Enable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Enable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Enable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Enable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Enable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Enable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Enable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Enable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Enable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Enable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Enable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Enable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Enable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Enable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Enable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Enable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Input Change Interrupt Disable" ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Input Change Interrupt Disable" ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Input Change Interrupt Disable" ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Input Change Interrupt Disable" ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Input Change Interrupt Disable" ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Input Change Interrupt Disable" ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Input Change Interrupt Disable" ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Input Change Interrupt Disable" ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Input Change Interrupt Disable" ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Input Change Interrupt Disable" ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Input Change Interrupt Disable" ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Input Change Interrupt Disable" ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Input Change Interrupt Disable" ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Input Change Interrupt Disable" ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Input Change Interrupt Disable" ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Input Change Interrupt Disable" ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Input Change Interrupt Disable" ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Input Change Interrupt Disable" ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Input Change Interrupt Disable" ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Input Change Interrupt Disable" ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Input Change Interrupt Disable" ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Input Change Interrupt Disable" ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Input Change Interrupt Disable" ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Input Change Interrupt Disable" ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Input Change Interrupt Disable" ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Input Change Interrupt Disable" ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Input Change Interrupt Disable" ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Input Change Interrupt Disable" ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Input Change Interrupt Disable" ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Input Change Interrupt Disable" ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Input Change Interrupt Disable" ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Input Change Interrupt Disable" ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Mask" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Mask" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Mask" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Mask" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Mask" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Mask" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Mask" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Mask" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Mask" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Mask" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Mask" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Mask" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Mask" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Mask" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Mask" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Mask" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Mask" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Mask" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Mask" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Mask" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Mask" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Mask" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Mask" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Mask" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Mask" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Mask" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Mask" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Mask" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Mask" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Mask" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Mask" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Mask" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Interrupt Status Register" ] pub struct ISR { register : :: vcell :: VolatileCell < u32 > } # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Input Change Interrupt Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Input Change Interrupt Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Input Change Interrupt Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Input Change Interrupt Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Input Change Interrupt Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Input Change Interrupt Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Input Change Interrupt Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Input Change Interrupt Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Input Change Interrupt Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Input Change Interrupt Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Input Change Interrupt Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Input Change Interrupt Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Input Change Interrupt Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Input Change Interrupt Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Input Change Interrupt Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Input Change Interrupt Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Input Change Interrupt Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Input Change Interrupt Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Input Change Interrupt Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Input Change Interrupt Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Input Change Interrupt Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Input Change Interrupt Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Input Change Interrupt Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Input Change Interrupt Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Input Change Interrupt Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Input Change Interrupt Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Input Change Interrupt Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Input Change Interrupt Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Input Change Interrupt Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Input Change Interrupt Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Input Change Interrupt Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Input Change Interrupt Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Multi-driver Enable Register" ] pub struct MDER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Enable Register" ] pub mod mder { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Disable Register" ] pub struct MDDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Disable Register" ] pub mod mddr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: MDDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Multi Drive Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Multi Drive Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Multi Drive Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Multi Drive Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Multi Drive Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Multi Drive Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Multi Drive Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Multi Drive Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Multi Drive Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Multi Drive Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Multi Drive Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Multi Drive Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Multi Drive Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Multi Drive Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Multi Drive Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Multi Drive Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Multi Drive Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Multi Drive Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Multi Drive Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Multi Drive Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Multi Drive Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Multi Drive Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Multi Drive Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Multi Drive Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Multi Drive Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Multi Drive Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Multi Drive Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Multi Drive Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Multi Drive Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Multi Drive Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Multi Drive Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Multi Drive Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Multi-driver Status Register" ] pub struct MDSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Multi-driver Status Register" ] pub mod mdsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: MDSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Multi Drive Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Multi Drive Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Multi Drive Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Multi Drive Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Multi Drive Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Multi Drive Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Multi Drive Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Multi Drive Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Multi Drive Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Multi Drive Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Multi Drive Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Multi Drive Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Multi Drive Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Multi Drive Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Multi Drive Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Multi Drive Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Multi Drive Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Multi Drive Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Multi Drive Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Multi Drive Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Multi Drive Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Multi Drive Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Multi Drive Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Multi Drive Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Multi Drive Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Multi Drive Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Multi Drive Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Multi Drive Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Multi Drive Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Multi Drive Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Multi Drive Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Multi Drive Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Pull-up Disable Register" ] pub struct PUDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Disable Register" ] pub mod pudr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pull-up Enable Register" ] pub struct PUER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pull-up Enable Register" ] pub mod puer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: PUER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Pull Up Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Pull Up Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Pull Up Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Pull Up Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Pull Up Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Pull Up Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Pull Up Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Pull Up Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Pull Up Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Pull Up Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Pull Up Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Pull Up Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Pull Up Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Pull Up Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Pull Up Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Pull Up Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Pull Up Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Pull Up Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Pull Up Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Pull Up Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Pull Up Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Pull Up Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Pull Up Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Pull Up Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Pull Up Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Pull Up Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Pull Up Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Pull Up Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Pull Up Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Pull Up Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Pull Up Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Pull Up Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Pad Pull-up Status Register" ] pub struct PUSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Pad Pull-up Status Register" ] pub mod pusr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: PUSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Pull Up Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Pull Up Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Pull Up Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Pull Up Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Pull Up Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Pull Up Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Pull Up Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Pull Up Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Pull Up Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Pull Up Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Pull Up Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Pull Up Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Pull Up Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Pull Up Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Pull Up Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Pull Up Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Pull Up Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Pull Up Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Pull Up Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Pull Up Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Pull Up Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Pull Up Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Pull Up Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Pull Up Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Pull Up Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Pull Up Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Pull Up Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Pull Up Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Pull Up Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Pull Up Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Pull Up Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Pull Up Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Peripheral AB Select Register" ] pub struct ABSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Peripheral AB Select Register" ] pub mod absr { # [ 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 :: ABSR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Peripheral A Select." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { 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 A Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Peripheral A Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Peripheral A Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Peripheral A Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Peripheral A Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Peripheral A Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Peripheral A Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Peripheral A Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Peripheral A Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Peripheral A Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Peripheral A Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Peripheral A Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Peripheral A Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Peripheral A Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Peripheral A Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Peripheral A Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Peripheral A Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Peripheral A Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Peripheral A Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Peripheral A Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Peripheral A Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Peripheral A Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Peripheral A Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Peripheral A Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Peripheral A Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Peripheral A Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Peripheral A Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Peripheral A Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Peripheral A Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Peripheral A Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Peripheral A Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Peripheral A Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub struct SCIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "System Clock Glitch Input Filter Select Register" ] pub mod scifsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SCIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - System Clock Glitch Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Debouncing Input Filter Select Register" ] pub struct DIFSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Debouncing Input Filter Select Register" ] pub mod difsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: DIFSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Debouncing Filtering Select." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Debouncing Filtering Select." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Debouncing Filtering Select." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Debouncing Filtering Select." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Debouncing Filtering Select." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Debouncing Filtering Select." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Debouncing Filtering Select." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Debouncing Filtering Select." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Debouncing Filtering Select." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Debouncing Filtering Select." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Debouncing Filtering Select." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Debouncing Filtering Select." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Debouncing Filtering Select." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Debouncing Filtering Select." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Debouncing Filtering Select." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Debouncing Filtering Select." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Debouncing Filtering Select." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Debouncing Filtering Select." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Debouncing Filtering Select." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Debouncing Filtering Select." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Debouncing Filtering Select." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Debouncing Filtering Select." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Debouncing Filtering Select." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Debouncing Filtering Select." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Debouncing Filtering Select." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Debouncing Filtering Select." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Debouncing Filtering Select." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Debouncing Filtering Select." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Debouncing Filtering Select." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Debouncing Filtering Select." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Debouncing Filtering Select." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Debouncing Filtering Select." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub struct IFDGSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Glitch or Debouncing Input Filter Clock Selection Status Register" ] pub mod ifdgsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IFDGSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Glitch or Debouncing Filter Selection Status" ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Slow Clock Divider Debouncing Register" ] pub struct SCDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Slow Clock Divider Debouncing Register" ] pub mod scdr { # [ 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 :: SCDR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 DIVR { bits : u16 , } impl DIVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u16 { self . bits } } # [ doc = r" Proxy" ] pub struct _DIVW < 'a > { w : & 'a mut W , } impl < 'a > _DIVW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u16 ) -> & 'a mut W { const MASK : u16 = 0x3fff ; 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & self ) -> DIVR { let bits = { const MASK : u16 = 0x3fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; DIVR { 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:13 - Slow Clock Divider Selection for Debouncing" ] # [ inline ] pub fn div ( & mut self ) -> _DIVW { _DIVW { w : self } } } } # [ doc = "Output Write Enable" ] pub struct OWER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Enable" ] pub mod ower { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Disable" ] pub struct OWDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Disable" ] pub mod owdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: OWDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Output Write Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Output Write Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Output Write Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Output Write Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Output Write Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Output Write Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Output Write Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Output Write Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Output Write Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Output Write Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Output Write Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Output Write Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Output Write Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Output Write Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Output Write Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Output Write Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Output Write Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Output Write Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Output Write Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Output Write Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Output Write Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Output Write Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Output Write Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Output Write Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Output Write Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Output Write Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Output Write Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Output Write Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Output Write Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Output Write Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Output Write Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Output Write Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Output Write Status Register" ] pub struct OWSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Output Write Status Register" ] pub mod owsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: OWSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Output Write Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Output Write Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Output Write Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Output Write Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Output Write Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Output Write Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Output Write Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Output Write Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Output Write Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Output Write Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Output Write Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Output Write Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Output Write Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Output Write Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Output Write Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Output Write Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Output Write Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Output Write Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Output Write Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Output Write Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Output Write Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Output Write Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Output Write Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Output Write Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Output Write Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Output Write Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Output Write Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Output Write Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Output Write Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Output Write Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Output Write Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Output Write Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Additional Interrupt Modes Enable Register" ] pub struct AIMER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Enable Register" ] pub mod aimer { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Enable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Disables Register" ] pub struct AIMDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Disables Register" ] pub mod aimdr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: AIMDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Additional Interrupt Modes Disable." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Additional Interrupt Modes Mask Register" ] pub struct AIMMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Additional Interrupt Modes Mask Register" ] pub mod aimmr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: AIMMR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Peripheral CD Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Peripheral CD Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Peripheral CD Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Peripheral CD Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Peripheral CD Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Peripheral CD Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Peripheral CD Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Peripheral CD Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Peripheral CD Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Peripheral CD Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Peripheral CD Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Peripheral CD Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Peripheral CD Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Peripheral CD Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Peripheral CD Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Peripheral CD Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Peripheral CD Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Peripheral CD Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Peripheral CD Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Peripheral CD Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Peripheral CD Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Peripheral CD Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Peripheral CD Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Peripheral CD Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Peripheral CD Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Peripheral CD Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Peripheral CD Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Peripheral CD Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Peripheral CD Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Peripheral CD Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Peripheral CD Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Peripheral CD Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Edge Select Register" ] pub struct ESR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge Select Register" ] pub mod esr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: ESR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Edge Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Edge Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Edge Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Edge Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Edge Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Edge Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Edge Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Edge Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Edge Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Edge Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Edge Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Edge Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Edge Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Edge Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Edge Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Edge Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Edge Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Edge Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Edge Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Edge Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Edge Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Edge Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Edge Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Edge Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Edge Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Edge Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Edge Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Edge Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Edge Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Edge Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Edge Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Edge Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Level Select Register" ] pub struct LSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Level Select Register" ] pub mod lsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: LSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Edge/Level Status Register" ] pub struct ELSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Edge/Level Status Register" ] pub mod elsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: ELSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge/Level Interrupt source selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Falling Edge/Low Level Select Register" ] pub struct FELLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Falling Edge/Low Level Select Register" ] pub mod fellsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: FELLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Falling Edge/Low Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Rising Edge/ High Level Select Register" ] pub struct REHLSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Rising Edge/ High Level Select Register" ] pub mod rehlsr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: REHLSR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _P0W < 'a > { w : & 'a mut W , } impl < 'a > _P0W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P1W < 'a > { w : & 'a mut W , } impl < 'a > _P1W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P2W < 'a > { w : & 'a mut W , } impl < 'a > _P2W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P3W < 'a > { w : & 'a mut W , } impl < 'a > _P3W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P4W < 'a > { w : & 'a mut W , } impl < 'a > _P4W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P5W < 'a > { w : & 'a mut W , } impl < 'a > _P5W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P6W < 'a > { w : & 'a mut W , } impl < 'a > _P6W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P7W < 'a > { w : & 'a mut W , } impl < 'a > _P7W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P8W < 'a > { w : & 'a mut W , } impl < 'a > _P8W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P9W < 'a > { w : & 'a mut W , } impl < 'a > _P9W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P10W < 'a > { w : & 'a mut W , } impl < 'a > _P10W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P11W < 'a > { w : & 'a mut W , } impl < 'a > _P11W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P12W < 'a > { w : & 'a mut W , } impl < 'a > _P12W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P13W < 'a > { w : & 'a mut W , } impl < 'a > _P13W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P14W < 'a > { w : & 'a mut W , } impl < 'a > _P14W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P15W < 'a > { w : & 'a mut W , } impl < 'a > _P15W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P16W < 'a > { w : & 'a mut W , } impl < 'a > _P16W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P17W < 'a > { w : & 'a mut W , } impl < 'a > _P17W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P18W < 'a > { w : & 'a mut W , } impl < 'a > _P18W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P19W < 'a > { w : & 'a mut W , } impl < 'a > _P19W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P20W < 'a > { w : & 'a mut W , } impl < 'a > _P20W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P21W < 'a > { w : & 'a mut W , } impl < 'a > _P21W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P22W < 'a > { w : & 'a mut W , } impl < 'a > _P22W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P23W < 'a > { w : & 'a mut W , } impl < 'a > _P23W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P24W < 'a > { w : & 'a mut W , } impl < 'a > _P24W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P25W < 'a > { w : & 'a mut W , } impl < 'a > _P25W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P26W < 'a > { w : & 'a mut W , } impl < 'a > _P26W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P27W < 'a > { w : & 'a mut W , } impl < 'a > _P27W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P28W < 'a > { w : & 'a mut W , } impl < 'a > _P28W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P29W < 'a > { w : & 'a mut W , } impl < 'a > _P29W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P30W < 'a > { w : & 'a mut W , } impl < 'a > _P30W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _P31W < 'a > { w : & 'a mut W , } impl < 'a > _P31W < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p0 ( & mut self ) -> _P0W { _P0W { w : self } } # [ doc = "Bit 1 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p1 ( & mut self ) -> _P1W { _P1W { w : self } } # [ doc = "Bit 2 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p2 ( & mut self ) -> _P2W { _P2W { w : self } } # [ doc = "Bit 3 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p3 ( & mut self ) -> _P3W { _P3W { w : self } } # [ doc = "Bit 4 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p4 ( & mut self ) -> _P4W { _P4W { w : self } } # [ doc = "Bit 5 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p5 ( & mut self ) -> _P5W { _P5W { w : self } } # [ doc = "Bit 6 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p6 ( & mut self ) -> _P6W { _P6W { w : self } } # [ doc = "Bit 7 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p7 ( & mut self ) -> _P7W { _P7W { w : self } } # [ doc = "Bit 8 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p8 ( & mut self ) -> _P8W { _P8W { w : self } } # [ doc = "Bit 9 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p9 ( & mut self ) -> _P9W { _P9W { w : self } } # [ doc = "Bit 10 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p10 ( & mut self ) -> _P10W { _P10W { w : self } } # [ doc = "Bit 11 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p11 ( & mut self ) -> _P11W { _P11W { w : self } } # [ doc = "Bit 12 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p12 ( & mut self ) -> _P12W { _P12W { w : self } } # [ doc = "Bit 13 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p13 ( & mut self ) -> _P13W { _P13W { w : self } } # [ doc = "Bit 14 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p14 ( & mut self ) -> _P14W { _P14W { w : self } } # [ doc = "Bit 15 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p15 ( & mut self ) -> _P15W { _P15W { w : self } } # [ doc = "Bit 16 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p16 ( & mut self ) -> _P16W { _P16W { w : self } } # [ doc = "Bit 17 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p17 ( & mut self ) -> _P17W { _P17W { w : self } } # [ doc = "Bit 18 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p18 ( & mut self ) -> _P18W { _P18W { w : self } } # [ doc = "Bit 19 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p19 ( & mut self ) -> _P19W { _P19W { w : self } } # [ doc = "Bit 20 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p20 ( & mut self ) -> _P20W { _P20W { w : self } } # [ doc = "Bit 21 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p21 ( & mut self ) -> _P21W { _P21W { w : self } } # [ doc = "Bit 22 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p22 ( & mut self ) -> _P22W { _P22W { w : self } } # [ doc = "Bit 23 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p23 ( & mut self ) -> _P23W { _P23W { w : self } } # [ doc = "Bit 24 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p24 ( & mut self ) -> _P24W { _P24W { w : self } } # [ doc = "Bit 25 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p25 ( & mut self ) -> _P25W { _P25W { w : self } } # [ doc = "Bit 26 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p26 ( & mut self ) -> _P26W { _P26W { w : self } } # [ doc = "Bit 27 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p27 ( & mut self ) -> _P27W { _P27W { w : self } } # [ doc = "Bit 28 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p28 ( & mut self ) -> _P28W { _P28W { w : self } } # [ doc = "Bit 29 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p29 ( & mut self ) -> _P29W { _P29W { w : self } } # [ doc = "Bit 30 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p30 ( & mut self ) -> _P30W { _P30W { w : self } } # [ doc = "Bit 31 - Rising Edge /High Level Interrupt Selection." ] # [ inline ] pub fn p31 ( & mut self ) -> _P31W { _P31W { w : self } } } } # [ doc = "Fall/Rise - Low/High Status Register" ] pub struct FRLHSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Fall/Rise - Low/High Status Register" ] pub mod frlhsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: FRLHSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Edge /Level Interrupt Source Selection." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Lock Status" ] pub struct LOCKSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Lock Status" ] pub mod locksr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: LOCKSR { # [ 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 P0R { bits : bool , } impl P0R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P1R { bits : bool , } impl P1R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P2R { bits : bool , } impl P2R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P3R { bits : bool , } impl P3R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P4R { bits : bool , } impl P4R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P5R { bits : bool , } impl P5R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P6R { bits : bool , } impl P6R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P7R { bits : bool , } impl P7R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P8R { bits : bool , } impl P8R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P9R { bits : bool , } impl P9R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P10R { bits : bool , } impl P10R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P11R { bits : bool , } impl P11R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P12R { bits : bool , } impl P12R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P13R { bits : bool , } impl P13R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P14R { bits : bool , } impl P14R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P15R { bits : bool , } impl P15R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P16R { bits : bool , } impl P16R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P17R { bits : bool , } impl P17R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P18R { bits : bool , } impl P18R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P19R { bits : bool , } impl P19R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P20R { bits : bool , } impl P20R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P21R { bits : bool , } impl P21R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P22R { bits : bool , } impl P22R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P23R { bits : bool , } impl P23R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P24R { bits : bool , } impl P24R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P25R { bits : bool , } impl P25R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P26R { bits : bool , } impl P26R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P27R { bits : bool , } impl P27R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P28R { bits : bool , } impl P28R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P29R { bits : bool , } impl P29R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P30R { bits : bool , } impl P30R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct P31R { bits : bool , } impl P31R { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Lock Status." ] # [ inline ] pub fn p0 ( & self ) -> P0R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P0R { bits } } # [ doc = "Bit 1 - Lock Status." ] # [ inline ] pub fn p1 ( & self ) -> P1R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P1R { bits } } # [ doc = "Bit 2 - Lock Status." ] # [ inline ] pub fn p2 ( & self ) -> P2R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P2R { bits } } # [ doc = "Bit 3 - Lock Status." ] # [ inline ] pub fn p3 ( & self ) -> P3R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P3R { bits } } # [ doc = "Bit 4 - Lock Status." ] # [ inline ] pub fn p4 ( & self ) -> P4R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P4R { bits } } # [ doc = "Bit 5 - Lock Status." ] # [ inline ] pub fn p5 ( & self ) -> P5R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P5R { bits } } # [ doc = "Bit 6 - Lock Status." ] # [ inline ] pub fn p6 ( & self ) -> P6R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P6R { bits } } # [ doc = "Bit 7 - Lock Status." ] # [ inline ] pub fn p7 ( & self ) -> P7R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P7R { bits } } # [ doc = "Bit 8 - Lock Status." ] # [ inline ] pub fn p8 ( & self ) -> P8R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P8R { bits } } # [ doc = "Bit 9 - Lock Status." ] # [ inline ] pub fn p9 ( & self ) -> P9R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P9R { bits } } # [ doc = "Bit 10 - Lock Status." ] # [ inline ] pub fn p10 ( & self ) -> P10R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P10R { bits } } # [ doc = "Bit 11 - Lock Status." ] # [ inline ] pub fn p11 ( & self ) -> P11R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P11R { bits } } # [ doc = "Bit 12 - Lock Status." ] # [ inline ] pub fn p12 ( & self ) -> P12R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P12R { bits } } # [ doc = "Bit 13 - Lock Status." ] # [ inline ] pub fn p13 ( & self ) -> P13R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P13R { bits } } # [ doc = "Bit 14 - Lock Status." ] # [ inline ] pub fn p14 ( & self ) -> P14R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P14R { bits } } # [ doc = "Bit 15 - Lock Status." ] # [ inline ] pub fn p15 ( & self ) -> P15R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P15R { bits } } # [ doc = "Bit 16 - Lock Status." ] # [ inline ] pub fn p16 ( & self ) -> P16R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P16R { bits } } # [ doc = "Bit 17 - Lock Status." ] # [ inline ] pub fn p17 ( & self ) -> P17R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P17R { bits } } # [ doc = "Bit 18 - Lock Status." ] # [ inline ] pub fn p18 ( & self ) -> P18R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P18R { bits } } # [ doc = "Bit 19 - Lock Status." ] # [ inline ] pub fn p19 ( & self ) -> P19R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P19R { bits } } # [ doc = "Bit 20 - Lock Status." ] # [ inline ] pub fn p20 ( & self ) -> P20R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P20R { bits } } # [ doc = "Bit 21 - Lock Status." ] # [ inline ] pub fn p21 ( & self ) -> P21R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P21R { bits } } # [ doc = "Bit 22 - Lock Status." ] # [ inline ] pub fn p22 ( & self ) -> P22R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P22R { bits } } # [ doc = "Bit 23 - Lock Status." ] # [ inline ] pub fn p23 ( & self ) -> P23R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P23R { bits } } # [ doc = "Bit 24 - Lock Status." ] # [ inline ] pub fn p24 ( & self ) -> P24R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P24R { bits } } # [ doc = "Bit 25 - Lock Status." ] # [ inline ] pub fn p25 ( & self ) -> P25R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P25R { bits } } # [ doc = "Bit 26 - Lock Status." ] # [ inline ] pub fn p26 ( & self ) -> P26R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P26R { bits } } # [ doc = "Bit 27 - Lock Status." ] # [ inline ] pub fn p27 ( & self ) -> P27R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P27R { bits } } # [ doc = "Bit 28 - Lock Status." ] # [ inline ] pub fn p28 ( & self ) -> P28R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P28R { bits } } # [ doc = "Bit 29 - Lock Status." ] # [ inline ] pub fn p29 ( & self ) -> P29R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P29R { bits } } # [ doc = "Bit 30 - Lock Status." ] # [ inline ] pub fn p30 ( & self ) -> P30R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P30R { bits } } # [ doc = "Bit 31 - Lock Status." ] # [ inline ] pub fn p31 ( & self ) -> P31R { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; P31R { bits } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPKEYR { bits : u32 , } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < '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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { let bits = { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; WPKEYR { 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } # [ doc = "Write Protect Status Register" ] pub struct WPSR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Status Register" ] pub mod wpsr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: WPSR { # [ 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 WPVSR { bits : bool , } impl WPVSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WPVSRCR { bits : u16 , } impl WPVSRCR { # [ 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 = "Bit 0 - Write Protect Violation Status" ] # [ inline ] pub fn wpvs ( & self ) -> WPVSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPVSR { bits } } # [ doc = "Bits 8:23 - Write Protect Violation Source" ] # [ inline ] pub fn wpvsrc ( & self ) -> WPVSRCR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WPVSRCR { bits } } } } } # [ doc = "Reset Controller" ] pub struct RSTC { _marker : PhantomData < * const ( ) > } unsafe impl Send for RSTC { } impl RSTC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const rstc :: RegisterBlock { 0x400e_1a00 as * const _ } } impl Deref for RSTC { type Target = rstc :: RegisterBlock ; fn deref ( & self ) -> & rstc :: RegisterBlock { unsafe { & * RSTC :: ptr ( ) } } } # [ doc = "Reset Controller" ] pub mod rstc { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Status Register" ] pub sr : SR , # [ doc = "0x08 - Mode Register" ] pub mr : MR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _PROCRSTW < 'a > { w : & 'a mut W , } impl < 'a > _PROCRSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _PERRSTW < 'a > { w : & 'a mut W , } impl < 'a > _PERRSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _EXTRSTW < 'a > { w : & 'a mut W , } impl < 'a > _EXTRSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `KEY`" ] pub enum KEYW { # [ doc = "Writing any other value in this field aborts the write operation." ] PASSWD } impl KEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { KEYW :: PASSWD => 165 } } } # [ doc = r" Proxy" ] pub struct _KEYW < 'a > { w : & 'a mut W , } impl < 'a > _KEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : KEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( KEYW :: PASSWD ) } # [ 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 } } impl W { # [ doc = "Bit 0 - Processor Reset" ] # [ inline ] pub fn procrst ( & mut self ) -> _PROCRSTW { _PROCRSTW { w : self } } # [ doc = "Bit 2 - Peripheral Reset" ] # [ inline ] pub fn perrst ( & mut self ) -> _PERRSTW { _PERRSTW { w : self } } # [ doc = "Bit 3 - External Reset" ] # [ inline ] pub fn extrst ( & mut self ) -> _EXTRSTW { _EXTRSTW { w : self } } # [ doc = "Bits 24:31 - System Reset Key" ] # [ inline ] pub fn key ( & mut self ) -> _KEYW { _KEYW { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 URSTSR { bits : bool , } impl URSTSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `RSTTYP`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RSTTYPR { # [ doc = "First power-up Reset" ] GENERALRESET , # [ doc = "Return from Backup Mode" ] BACKUPRESET , # [ doc = "Watchdog fault occurred" ] WATCHDOGRESET , # [ doc = "Processor reset required by the software" ] SOFTWARERESET , # [ doc = "NRST pin detected low" ] USERRESET , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl RSTTYPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { RSTTYPR :: GENERALRESET => 0 , RSTTYPR :: BACKUPRESET => 0x01 , RSTTYPR :: WATCHDOGRESET => 0x02 , RSTTYPR :: SOFTWARERESET => 0x03 , RSTTYPR :: USERRESET => 0x04 , RSTTYPR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> RSTTYPR { match value { 0 => RSTTYPR :: GENERALRESET , 1 => RSTTYPR :: BACKUPRESET , 2 => RSTTYPR :: WATCHDOGRESET , 3 => RSTTYPR :: SOFTWARERESET , 4 => RSTTYPR :: USERRESET , i => RSTTYPR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `GENERALRESET`" ] # [ inline ] pub fn is_general_reset ( & self ) -> bool { * self == RSTTYPR :: GENERALRESET } # [ doc = "Checks if the value of the field is `BACKUPRESET`" ] # [ inline ] pub fn is_backup_reset ( & self ) -> bool { * self == RSTTYPR :: BACKUPRESET } # [ doc = "Checks if the value of the field is `WATCHDOGRESET`" ] # [ inline ] pub fn is_watchdog_reset ( & self ) -> bool { * self == RSTTYPR :: WATCHDOGRESET } # [ doc = "Checks if the value of the field is `SOFTWARERESET`" ] # [ inline ] pub fn is_software_reset ( & self ) -> bool { * self == RSTTYPR :: SOFTWARERESET } # [ doc = "Checks if the value of the field is `USERRESET`" ] # [ inline ] pub fn is_user_reset ( & self ) -> bool { * self == RSTTYPR :: USERRESET } } # [ doc = r" Value of the field" ] pub struct NRSTLR { bits : bool , } impl NRSTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SRCMPR { bits : bool , } impl SRCMPR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - User Reset Status" ] # [ inline ] pub fn ursts ( & self ) -> URSTSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; URSTSR { bits } } # [ doc = "Bits 8:10 - Reset Type" ] # [ inline ] pub fn rsttyp ( & self ) -> RSTTYPR { RSTTYPR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 16 - NRST Pin Level" ] # [ inline ] pub fn nrstl ( & self ) -> NRSTLR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NRSTLR { bits } } # [ doc = "Bit 17 - Software Reset Command in Progress" ] # [ inline ] pub fn srcmp ( & self ) -> SRCMPR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SRCMPR { bits } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 URSTENR { bits : bool , } impl URSTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct URSTIENR { bits : bool , } impl URSTIENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ERSTLR { bits : u8 , } impl ERSTLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `KEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum KEYR { # [ doc = "Writing any other value in this field aborts the write operation.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl KEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { KEYR :: PASSWD => 0xa5 , KEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> KEYR { match value { 165 => KEYR :: PASSWD , i => KEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == KEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _URSTENW < 'a > { w : & 'a mut W , } impl < 'a > _URSTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _URSTIENW < 'a > { w : & 'a mut W , } impl < 'a > _URSTIENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ERSTLW < 'a > { w : & 'a mut W , } impl < 'a > _ERSTLW < '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 = "Values that can be written to the field `KEY`" ] pub enum KEYW { # [ doc = "Writing any other value in this field aborts the write operation.Always reads as 0." ] PASSWD } impl KEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { KEYW :: PASSWD => 165 } } } # [ doc = r" Proxy" ] pub struct _KEYW < 'a > { w : & 'a mut W , } impl < 'a > _KEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : KEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( KEYW :: PASSWD ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - User Reset Enable" ] # [ inline ] pub fn ursten ( & self ) -> URSTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; URSTENR { bits } } # [ doc = "Bit 4 - User Reset Interrupt Enable" ] # [ inline ] pub fn urstien ( & self ) -> URSTIENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; URSTIENR { bits } } # [ doc = "Bits 8:11 - External Reset Length" ] # [ inline ] pub fn erstl ( & self ) -> ERSTLR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; ERSTLR { bits } } # [ doc = "Bits 24:31 - Write Access Password" ] # [ inline ] pub fn key ( & self ) -> KEYR { KEYR :: _from ( { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 0 - User Reset Enable" ] # [ inline ] pub fn ursten ( & mut self ) -> _URSTENW { _URSTENW { w : self } } # [ doc = "Bit 4 - User Reset Interrupt Enable" ] # [ inline ] pub fn urstien ( & mut self ) -> _URSTIENW { _URSTIENW { w : self } } # [ doc = "Bits 8:11 - External Reset Length" ] # [ inline ] pub fn erstl ( & mut self ) -> _ERSTLW { _ERSTLW { w : self } } # [ doc = "Bits 24:31 - Write Access Password" ] # [ inline ] pub fn key ( & mut self ) -> _KEYW { _KEYW { w : self } } } } } # [ doc = "Supply Controller" ] pub struct SUPC { _marker : PhantomData < * const ( ) > } unsafe impl Send for SUPC { } impl SUPC { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const supc :: RegisterBlock { 0x400e_1a10 as * const _ } } impl Deref for SUPC { type Target = supc :: RegisterBlock ; fn deref ( & self ) -> & supc :: RegisterBlock { unsafe { & * SUPC :: ptr ( ) } } } # [ doc = "Supply Controller" ] pub mod supc { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Supply Controller Control Register" ] pub cr : CR , # [ doc = "0x04 - Supply Controller Supply Monitor Mode Register" ] pub smmr : SMMR , # [ doc = "0x08 - Supply Controller Mode Register" ] pub mr : MR , # [ doc = "0x0c - Supply Controller Wake-up Mode Register" ] pub wumr : WUMR , # [ doc = "0x10 - Supply Controller Wake-up Inputs Register" ] pub wuir : WUIR , # [ doc = "0x14 - Supply Controller Status Register" ] pub sr : SR , } # [ doc = "Supply Controller Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Supply Controller Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = "Values that can be written to the field `VROFF`" ] pub enum VROFFW { # [ doc = "no effect." ] NO_EFFECT , # [ doc = "if KEY is correct, asserts the vddcore_nreset and stops the voltage regulator." ] STOP_VREG } impl VROFFW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { VROFFW :: NO_EFFECT => false , VROFFW :: STOP_VREG => true } } } # [ doc = r" Proxy" ] pub struct _VROFFW < 'a > { w : & 'a mut W , } impl < 'a > _VROFFW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : VROFFW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "no effect." ] # [ inline ] pub fn no_effect ( self ) -> & 'a mut W { self . variant ( VROFFW :: NO_EFFECT ) } # [ doc = "if KEY is correct, asserts the vddcore_nreset and stops the voltage regulator." ] # [ inline ] pub fn stop_vreg ( self ) -> & 'a mut W { self . variant ( VROFFW :: STOP_VREG ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `XTALSEL`" ] pub enum XTALSELW { # [ doc = "no effect." ] NO_EFFECT , # [ doc = "if KEY is correct, switches the slow clock on the crystal oscillator output." ] CRYSTAL_SEL } impl XTALSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { XTALSELW :: NO_EFFECT => false , XTALSELW :: CRYSTAL_SEL => true } } } # [ doc = r" Proxy" ] pub struct _XTALSELW < 'a > { w : & 'a mut W , } impl < 'a > _XTALSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : XTALSELW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "no effect." ] # [ inline ] pub fn no_effect ( self ) -> & 'a mut W { self . variant ( XTALSELW :: NO_EFFECT ) } # [ doc = "if KEY is correct, switches the slow clock on the crystal oscillator output." ] # [ inline ] pub fn crystal_sel ( self ) -> & 'a mut W { self . variant ( XTALSELW :: CRYSTAL_SEL ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `KEY`" ] pub enum KEYW { # [ doc = "Writing any other value in this field aborts the write operation." ] PASSWD } impl KEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { KEYW :: PASSWD => 165 } } } # [ doc = r" Proxy" ] pub struct _KEYW < 'a > { w : & 'a mut W , } impl < 'a > _KEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : KEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( KEYW :: PASSWD ) } # [ 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 } } impl W { # [ doc = "Bit 2 - Voltage Regulator Off" ] # [ inline ] pub fn vroff ( & mut self ) -> _VROFFW { _VROFFW { w : self } } # [ doc = "Bit 3 - Crystal Oscillator Select" ] # [ inline ] pub fn xtalsel ( & mut self ) -> _XTALSELW { _XTALSELW { w : self } } # [ doc = "Bits 24:31 - Password" ] # [ inline ] pub fn key ( & mut self ) -> _KEYW { _KEYW { w : self } } } } # [ doc = "Supply Controller Supply Monitor Mode Register" ] pub struct SMMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Supply Controller Supply Monitor Mode Register" ] pub mod smmr { # [ 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 :: SMMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SMTHR { bits : u8 , } impl SMTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = "Possible values of the field `SMSMPL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMSMPLR { # [ doc = "Supply Monitor disabled" ] SMD , # [ doc = "Continuous Supply Monitor" ] CSM , # [ doc = "Supply Monitor enabled one SLCK period every 32 SLCK periods" ] _32SLCK , # [ doc = "Supply Monitor enabled one SLCK period every 256 SLCK periods" ] _256SLCK , # [ doc = "Supply Monitor enabled one SLCK period every 2,048 SLCK periods" ] _2048SLCK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl SMSMPLR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { SMSMPLR :: SMD => 0 , SMSMPLR :: CSM => 0x01 , SMSMPLR :: _32SLCK => 0x02 , SMSMPLR :: _256SLCK => 0x03 , SMSMPLR :: _2048SLCK => 0x04 , SMSMPLR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> SMSMPLR { match value { 0 => SMSMPLR :: SMD , 1 => SMSMPLR :: CSM , 2 => SMSMPLR :: _32SLCK , 3 => SMSMPLR :: _256SLCK , 4 => SMSMPLR :: _2048SLCK , i => SMSMPLR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `SMD`" ] # [ inline ] pub fn is_smd ( & self ) -> bool { * self == SMSMPLR :: SMD } # [ doc = "Checks if the value of the field is `CSM`" ] # [ inline ] pub fn is_csm ( & self ) -> bool { * self == SMSMPLR :: CSM } # [ doc = "Checks if the value of the field is `_32SLCK`" ] # [ inline ] pub fn is_32slck ( & self ) -> bool { * self == SMSMPLR :: _32SLCK } # [ doc = "Checks if the value of the field is `_256SLCK`" ] # [ inline ] pub fn is_256slck ( & self ) -> bool { * self == SMSMPLR :: _256SLCK } # [ doc = "Checks if the value of the field is `_2048SLCK`" ] # [ inline ] pub fn is_2048slck ( & self ) -> bool { * self == SMSMPLR :: _2048SLCK } } # [ doc = "Possible values of the field `SMRSTEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMRSTENR { # [ doc = "the core reset signal \"vddcore_nreset\" is not affected when a supply monitor detection occurs." ] NOT_ENABLE , # [ doc = "the core reset signal, vddcore_nreset is asserted when a supply monitor detection occurs." ] ENABLE } impl SMRSTENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMRSTENR :: NOT_ENABLE => false , SMRSTENR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMRSTENR { match value { false => SMRSTENR :: NOT_ENABLE , true => SMRSTENR :: ENABLE , } } # [ doc = "Checks if the value of the field is `NOT_ENABLE`" ] # [ inline ] pub fn is_not_enable ( & self ) -> bool { * self == SMRSTENR :: NOT_ENABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SMRSTENR :: ENABLE } } # [ doc = "Possible values of the field `SMIEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMIENR { # [ doc = "the SUPC interrupt signal is not affected when a supply monitor detection occurs." ] NOT_ENABLE , # [ doc = "the SUPC interrupt signal is asserted when a supply monitor detection occurs." ] ENABLE } impl SMIENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMIENR :: NOT_ENABLE => false , SMIENR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMIENR { match value { false => SMIENR :: NOT_ENABLE , true => SMIENR :: ENABLE , } } # [ doc = "Checks if the value of the field is `NOT_ENABLE`" ] # [ inline ] pub fn is_not_enable ( & self ) -> bool { * self == SMIENR :: NOT_ENABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SMIENR :: ENABLE } } # [ doc = r" Proxy" ] pub struct _SMTHW < 'a > { w : & 'a mut W , } impl < 'a > _SMTHW < '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 } } # [ doc = "Values that can be written to the field `SMSMPL`" ] pub enum SMSMPLW { # [ doc = "Supply Monitor disabled" ] SMD , # [ doc = "Continuous Supply Monitor" ] CSM , # [ doc = "Supply Monitor enabled one SLCK period every 32 SLCK periods" ] _32SLCK , # [ doc = "Supply Monitor enabled one SLCK period every 256 SLCK periods" ] _256SLCK , # [ doc = "Supply Monitor enabled one SLCK period every 2,048 SLCK periods" ] _2048SLCK } impl SMSMPLW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { SMSMPLW :: SMD => 0 , SMSMPLW :: CSM => 1 , SMSMPLW :: _32SLCK => 2 , SMSMPLW :: _256SLCK => 3 , SMSMPLW :: _2048SLCK => 4 } } } # [ doc = r" Proxy" ] pub struct _SMSMPLW < 'a > { w : & 'a mut W , } impl < 'a > _SMSMPLW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SMSMPLW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Supply Monitor disabled" ] # [ inline ] pub fn smd ( self ) -> & 'a mut W { self . variant ( SMSMPLW :: SMD ) } # [ doc = "Continuous Supply Monitor" ] # [ inline ] pub fn csm ( self ) -> & 'a mut W { self . variant ( SMSMPLW :: CSM ) } # [ doc = "Supply Monitor enabled one SLCK period every 32 SLCK periods" ] # [ inline ] pub fn _32slck ( self ) -> & 'a mut W { self . variant ( SMSMPLW :: _32SLCK ) } # [ doc = "Supply Monitor enabled one SLCK period every 256 SLCK periods" ] # [ inline ] pub fn _256slck ( self ) -> & 'a mut W { self . variant ( SMSMPLW :: _256SLCK ) } # [ doc = "Supply Monitor enabled one SLCK period every 2,048 SLCK periods" ] # [ inline ] pub fn _2048slck ( self ) -> & 'a mut W { self . variant ( SMSMPLW :: _2048SLCK ) } # [ 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 = "Values that can be written to the field `SMRSTEN`" ] pub enum SMRSTENW { # [ doc = "the core reset signal \"vddcore_nreset\" is not affected when a supply monitor detection occurs." ] NOT_ENABLE , # [ doc = "the core reset signal, vddcore_nreset is asserted when a supply monitor detection occurs." ] ENABLE } impl SMRSTENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SMRSTENW :: NOT_ENABLE => false , SMRSTENW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SMRSTENW < 'a > { w : & 'a mut W , } impl < 'a > _SMRSTENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SMRSTENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the core reset signal \"vddcore_nreset\" is not affected when a supply monitor detection occurs." ] # [ inline ] pub fn not_enable ( self ) -> & 'a mut W { self . variant ( SMRSTENW :: NOT_ENABLE ) } # [ doc = "the core reset signal, vddcore_nreset is asserted when a supply monitor detection occurs." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SMRSTENW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SMIEN`" ] pub enum SMIENW { # [ doc = "the SUPC interrupt signal is not affected when a supply monitor detection occurs." ] NOT_ENABLE , # [ doc = "the SUPC interrupt signal is asserted when a supply monitor detection occurs." ] ENABLE } impl SMIENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SMIENW :: NOT_ENABLE => false , SMIENW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SMIENW < 'a > { w : & 'a mut W , } impl < 'a > _SMIENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SMIENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the SUPC interrupt signal is not affected when a supply monitor detection occurs." ] # [ inline ] pub fn not_enable ( self ) -> & 'a mut W { self . variant ( SMIENW :: NOT_ENABLE ) } # [ doc = "the SUPC interrupt signal is asserted when a supply monitor detection occurs." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SMIENW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bits 0:3 - Supply Monitor Threshold" ] # [ inline ] pub fn smth ( & self ) -> SMTHR { let bits = { const MASK : u8 = 0x0f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SMTHR { bits } } # [ doc = "Bits 8:10 - Supply Monitor Sampling Period" ] # [ inline ] pub fn smsmpl ( & self ) -> SMSMPLR { SMSMPLR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bit 12 - Supply Monitor Reset Enable" ] # [ inline ] pub fn smrsten ( & self ) -> SMRSTENR { SMRSTENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Supply Monitor Interrupt Enable" ] # [ inline ] pub fn smien ( & self ) -> SMIENR { SMIENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } 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 - Supply Monitor Threshold" ] # [ inline ] pub fn smth ( & mut self ) -> _SMTHW { _SMTHW { w : self } } # [ doc = "Bits 8:10 - Supply Monitor Sampling Period" ] # [ inline ] pub fn smsmpl ( & mut self ) -> _SMSMPLW { _SMSMPLW { w : self } } # [ doc = "Bit 12 - Supply Monitor Reset Enable" ] # [ inline ] pub fn smrsten ( & mut self ) -> _SMRSTENW { _SMRSTENW { w : self } } # [ doc = "Bit 13 - Supply Monitor Interrupt Enable" ] # [ inline ] pub fn smien ( & mut self ) -> _SMIENW { _SMIENW { w : self } } } } # [ doc = "Supply Controller Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Supply Controller Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `BODRSTEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BODRSTENR { # [ doc = "the core reset signal \"vddcore_nreset\" is not affected when a brownout detection occurs." ] NOT_ENABLE , # [ doc = "the core reset signal, vddcore_nreset is asserted when a brownout detection occurs." ] ENABLE } impl BODRSTENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { BODRSTENR :: NOT_ENABLE => false , BODRSTENR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> BODRSTENR { match value { false => BODRSTENR :: NOT_ENABLE , true => BODRSTENR :: ENABLE , } } # [ doc = "Checks if the value of the field is `NOT_ENABLE`" ] # [ inline ] pub fn is_not_enable ( & self ) -> bool { * self == BODRSTENR :: NOT_ENABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == BODRSTENR :: ENABLE } } # [ doc = "Possible values of the field `BODDIS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BODDISR { # [ doc = "the core brownout detector is enabled." ] ENABLE , # [ doc = "the core brownout detector is disabled." ] DISABLE } impl BODDISR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { BODDISR :: ENABLE => false , BODDISR :: DISABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> BODDISR { match value { false => BODDISR :: ENABLE , true => BODDISR :: DISABLE , } } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == BODDISR :: ENABLE } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == BODDISR :: DISABLE } } # [ doc = "Possible values of the field `VDDIORDY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum VDDIORDYR { # [ doc = "VDDIO is removed (used before going to backup mode when backup batteries are used)" ] VDDIO_REMOVED , # [ doc = "VDDIO is present (used before going to backup mode when backup batteries are used)" ] VDDIO_PRESENT } impl VDDIORDYR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { VDDIORDYR :: VDDIO_REMOVED => false , VDDIORDYR :: VDDIO_PRESENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> VDDIORDYR { match value { false => VDDIORDYR :: VDDIO_REMOVED , true => VDDIORDYR :: VDDIO_PRESENT , } } # [ doc = "Checks if the value of the field is `VDDIO_REMOVED`" ] # [ inline ] pub fn is_vddio_removed ( & self ) -> bool { * self == VDDIORDYR :: VDDIO_REMOVED } # [ doc = "Checks if the value of the field is `VDDIO_PRESENT`" ] # [ inline ] pub fn is_vddio_present ( & self ) -> bool { * self == VDDIORDYR :: VDDIO_PRESENT } } # [ doc = "Possible values of the field `OSCBYPASS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum OSCBYPASSR { # [ doc = "no effect. Clock selection depends on XTALSEL value." ] NO_EFFECT , # [ doc = "the 32-KHz XTAL oscillator is selected and is put in bypass mode." ] BYPASS } impl OSCBYPASSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { OSCBYPASSR :: NO_EFFECT => false , OSCBYPASSR :: BYPASS => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> OSCBYPASSR { match value { false => OSCBYPASSR :: NO_EFFECT , true => OSCBYPASSR :: BYPASS , } } # [ doc = "Checks if the value of the field is `NO_EFFECT`" ] # [ inline ] pub fn is_no_effect ( & self ) -> bool { * self == OSCBYPASSR :: NO_EFFECT } # [ doc = "Checks if the value of the field is `BYPASS`" ] # [ inline ] pub fn is_bypass ( & self ) -> bool { * self == OSCBYPASSR :: BYPASS } } # [ doc = "Possible values of the field `KEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum KEYR { # [ doc = "Writing any other value in this field aborts the write operation." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl KEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { KEYR :: PASSWD => 0xa5 , KEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> KEYR { match value { 165 => KEYR :: PASSWD , i => KEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == KEYR :: PASSWD } } # [ doc = "Values that can be written to the field `BODRSTEN`" ] pub enum BODRSTENW { # [ doc = "the core reset signal \"vddcore_nreset\" is not affected when a brownout detection occurs." ] NOT_ENABLE , # [ doc = "the core reset signal, vddcore_nreset is asserted when a brownout detection occurs." ] ENABLE } impl BODRSTENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { BODRSTENW :: NOT_ENABLE => false , BODRSTENW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _BODRSTENW < 'a > { w : & 'a mut W , } impl < 'a > _BODRSTENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BODRSTENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the core reset signal \"vddcore_nreset\" is not affected when a brownout detection occurs." ] # [ inline ] pub fn not_enable ( self ) -> & 'a mut W { self . variant ( BODRSTENW :: NOT_ENABLE ) } # [ doc = "the core reset signal, vddcore_nreset is asserted when a brownout detection occurs." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( BODRSTENW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `BODDIS`" ] pub enum BODDISW { # [ doc = "the core brownout detector is enabled." ] ENABLE , # [ doc = "the core brownout detector is disabled." ] DISABLE } impl BODDISW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { BODDISW :: ENABLE => false , BODDISW :: DISABLE => true } } } # [ doc = r" Proxy" ] pub struct _BODDISW < 'a > { w : & 'a mut W , } impl < 'a > _BODDISW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : BODDISW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the core brownout detector is enabled." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( BODDISW :: ENABLE ) } # [ doc = "the core brownout detector is disabled." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( BODDISW :: DISABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `VDDIORDY`" ] pub enum VDDIORDYW { # [ doc = "VDDIO is removed (used before going to backup mode when backup batteries are used)" ] VDDIO_REMOVED , # [ doc = "VDDIO is present (used before going to backup mode when backup batteries are used)" ] VDDIO_PRESENT } impl VDDIORDYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { VDDIORDYW :: VDDIO_REMOVED => false , VDDIORDYW :: VDDIO_PRESENT => true } } } # [ doc = r" Proxy" ] pub struct _VDDIORDYW < 'a > { w : & 'a mut W , } impl < 'a > _VDDIORDYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : VDDIORDYW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "VDDIO is removed (used before going to backup mode when backup batteries are used)" ] # [ inline ] pub fn vddio_removed ( self ) -> & 'a mut W { self . variant ( VDDIORDYW :: VDDIO_REMOVED ) } # [ doc = "VDDIO is present (used before going to backup mode when backup batteries are used)" ] # [ inline ] pub fn vddio_present ( self ) -> & 'a mut W { self . variant ( VDDIORDYW :: VDDIO_PRESENT ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `OSCBYPASS`" ] pub enum OSCBYPASSW { # [ doc = "no effect. Clock selection depends on XTALSEL value." ] NO_EFFECT , # [ doc = "the 32-KHz XTAL oscillator is selected and is put in bypass mode." ] BYPASS } impl OSCBYPASSW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { OSCBYPASSW :: NO_EFFECT => false , OSCBYPASSW :: BYPASS => true } } } # [ doc = r" Proxy" ] pub struct _OSCBYPASSW < 'a > { w : & 'a mut W , } impl < 'a > _OSCBYPASSW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : OSCBYPASSW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "no effect. Clock selection depends on XTALSEL value." ] # [ inline ] pub fn no_effect ( self ) -> & 'a mut W { self . variant ( OSCBYPASSW :: NO_EFFECT ) } # [ doc = "the 32-KHz XTAL oscillator is selected and is put in bypass mode." ] # [ inline ] pub fn bypass ( self ) -> & 'a mut W { self . variant ( OSCBYPASSW :: BYPASS ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `KEY`" ] pub enum KEYW { # [ doc = "Writing any other value in this field aborts the write operation." ] PASSWD } impl KEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { KEYW :: PASSWD => 165 } } } # [ doc = r" Proxy" ] pub struct _KEYW < 'a > { w : & 'a mut W , } impl < 'a > _KEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : KEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( KEYW :: PASSWD ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 12 - Brownout Detector Reset Enable" ] # [ inline ] pub fn bodrsten ( & self ) -> BODRSTENR { BODRSTENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Brownout Detector Disable" ] # [ inline ] pub fn boddis ( & self ) -> BODDISR { BODDISR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 14 - VDDIO Ready" ] # [ inline ] pub fn vddiordy ( & self ) -> VDDIORDYR { VDDIORDYR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Oscillator Bypass" ] # [ inline ] pub fn oscbypass ( & self ) -> OSCBYPASSR { OSCBYPASSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 24:31 - Password Key" ] # [ inline ] pub fn key ( & self ) -> KEYR { KEYR :: _from ( { const MASK : u8 = 0xff ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x5a00 } } # [ 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 - Brownout Detector Reset Enable" ] # [ inline ] pub fn bodrsten ( & mut self ) -> _BODRSTENW { _BODRSTENW { w : self } } # [ doc = "Bit 13 - Brownout Detector Disable" ] # [ inline ] pub fn boddis ( & mut self ) -> _BODDISW { _BODDISW { w : self } } # [ doc = "Bit 14 - VDDIO Ready" ] # [ inline ] pub fn vddiordy ( & mut self ) -> _VDDIORDYW { _VDDIORDYW { w : self } } # [ doc = "Bit 20 - Oscillator Bypass" ] # [ inline ] pub fn oscbypass ( & mut self ) -> _OSCBYPASSW { _OSCBYPASSW { w : self } } # [ doc = "Bits 24:31 - Password Key" ] # [ inline ] pub fn key ( & mut self ) -> _KEYW { _KEYW { w : self } } } } # [ doc = "Supply Controller Wake-up Mode Register" ] pub struct WUMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Supply Controller Wake-up Mode Register" ] pub mod wumr { # [ 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 :: WUMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `FWUPEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FWUPENR { # [ doc = "the Force Wake-up pin has no wake-up effect." ] NOT_ENABLE , # [ doc = "the Force Wake-up pin low forces the wake-up of the core power supply." ] ENABLE } impl FWUPENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { FWUPENR :: NOT_ENABLE => false , FWUPENR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> FWUPENR { match value { false => FWUPENR :: NOT_ENABLE , true => FWUPENR :: ENABLE , } } # [ doc = "Checks if the value of the field is `NOT_ENABLE`" ] # [ inline ] pub fn is_not_enable ( & self ) -> bool { * self == FWUPENR :: NOT_ENABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == FWUPENR :: ENABLE } } # [ doc = "Possible values of the field `SMEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMENR { # [ doc = "the supply monitor detection has no wake-up effect." ] NOT_ENABLE , # [ doc = "the supply monitor detection forces the wake-up of the core power supply." ] ENABLE } impl SMENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMENR :: NOT_ENABLE => false , SMENR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMENR { match value { false => SMENR :: NOT_ENABLE , true => SMENR :: ENABLE , } } # [ doc = "Checks if the value of the field is `NOT_ENABLE`" ] # [ inline ] pub fn is_not_enable ( & self ) -> bool { * self == SMENR :: NOT_ENABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == SMENR :: ENABLE } } # [ doc = "Possible values of the field `RTTEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RTTENR { # [ doc = "the RTT alarm signal has no wake-up effect." ] NOT_ENABLE , # [ doc = "the RTT alarm signal forces the wake-up of the core power supply." ] ENABLE } impl RTTENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { RTTENR :: NOT_ENABLE => false , RTTENR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> RTTENR { match value { false => RTTENR :: NOT_ENABLE , true => RTTENR :: ENABLE , } } # [ doc = "Checks if the value of the field is `NOT_ENABLE`" ] # [ inline ] pub fn is_not_enable ( & self ) -> bool { * self == RTTENR :: NOT_ENABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == RTTENR :: ENABLE } } # [ doc = "Possible values of the field `RTCEN`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum RTCENR { # [ doc = "the RTC alarm signal has no wake-up effect." ] NOT_ENABLE , # [ doc = "the RTC alarm signal forces the wake-up of the core power supply." ] ENABLE } impl RTCENR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { RTCENR :: NOT_ENABLE => false , RTCENR :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> RTCENR { match value { false => RTCENR :: NOT_ENABLE , true => RTCENR :: ENABLE , } } # [ doc = "Checks if the value of the field is `NOT_ENABLE`" ] # [ inline ] pub fn is_not_enable ( & self ) -> bool { * self == RTCENR :: NOT_ENABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == RTCENR :: ENABLE } } # [ doc = "Possible values of the field `FWUPDBC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FWUPDBCR { # [ doc = "Immediate, no debouncing, detected active at least on one Slow Clock edge." ] IMMEDIATE , # [ doc = "FWUP shall be low for at least 3 SLCK periods" ] _3_SCLK , # [ doc = "FWUP shall be low for at least 32 SLCK periods" ] _32_SCLK , # [ doc = "FWUP shall be low for at least 512 SLCK periods" ] _512_SCLK , # [ doc = "FWUP shall be low for at least 4,096 SLCK periods" ] _4096_SCLK , # [ doc = "FWUP shall be low for at least 32,768 SLCK periods" ] _32768_SCLK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl FWUPDBCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { FWUPDBCR :: IMMEDIATE => 0 , FWUPDBCR :: _3_SCLK => 0x01 , FWUPDBCR :: _32_SCLK => 0x02 , FWUPDBCR :: _512_SCLK => 0x03 , FWUPDBCR :: _4096_SCLK => 0x04 , FWUPDBCR :: _32768_SCLK => 0x05 , FWUPDBCR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> FWUPDBCR { match value { 0 => FWUPDBCR :: IMMEDIATE , 1 => FWUPDBCR :: _3_SCLK , 2 => FWUPDBCR :: _32_SCLK , 3 => FWUPDBCR :: _512_SCLK , 4 => FWUPDBCR :: _4096_SCLK , 5 => FWUPDBCR :: _32768_SCLK , i => FWUPDBCR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `IMMEDIATE`" ] # [ inline ] pub fn is_immediate ( & self ) -> bool { * self == FWUPDBCR :: IMMEDIATE } # [ doc = "Checks if the value of the field is `_3_SCLK`" ] # [ inline ] pub fn is_3_sclk ( & self ) -> bool { * self == FWUPDBCR :: _3_SCLK } # [ doc = "Checks if the value of the field is `_32_SCLK`" ] # [ inline ] pub fn is_32_sclk ( & self ) -> bool { * self == FWUPDBCR :: _32_SCLK } # [ doc = "Checks if the value of the field is `_512_SCLK`" ] # [ inline ] pub fn is_512_sclk ( & self ) -> bool { * self == FWUPDBCR :: _512_SCLK } # [ doc = "Checks if the value of the field is `_4096_SCLK`" ] # [ inline ] pub fn is_4096_sclk ( & self ) -> bool { * self == FWUPDBCR :: _4096_SCLK } # [ doc = "Checks if the value of the field is `_32768_SCLK`" ] # [ inline ] pub fn is_32768_sclk ( & self ) -> bool { * self == FWUPDBCR :: _32768_SCLK } } # [ doc = "Possible values of the field `WKUPDBC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPDBCR { # [ doc = "Immediate, no debouncing, detected active at least on one Slow Clock edge." ] IMMEDIATE , # [ doc = "WKUPx shall be in its active state for at least 3 SLCK periods" ] _3_SCLK , # [ doc = "WKUPx shall be in its active state for at least 32 SLCK periods" ] _32_SCLK , # [ doc = "WKUPx shall be in its active state for at least 512 SLCK periods" ] _512_SCLK , # [ doc = "WKUPx shall be in its active state for at least 4,096 SLCK periods" ] _4096_SCLK , # [ doc = "WKUPx shall be in its active state for at least 32,768 SLCK periods" ] _32768_SCLK , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl WKUPDBCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { WKUPDBCR :: IMMEDIATE => 0 , WKUPDBCR :: _3_SCLK => 0x01 , WKUPDBCR :: _32_SCLK => 0x02 , WKUPDBCR :: _512_SCLK => 0x03 , WKUPDBCR :: _4096_SCLK => 0x04 , WKUPDBCR :: _32768_SCLK => 0x05 , WKUPDBCR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> WKUPDBCR { match value { 0 => WKUPDBCR :: IMMEDIATE , 1 => WKUPDBCR :: _3_SCLK , 2 => WKUPDBCR :: _32_SCLK , 3 => WKUPDBCR :: _512_SCLK , 4 => WKUPDBCR :: _4096_SCLK , 5 => WKUPDBCR :: _32768_SCLK , i => WKUPDBCR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `IMMEDIATE`" ] # [ inline ] pub fn is_immediate ( & self ) -> bool { * self == WKUPDBCR :: IMMEDIATE } # [ doc = "Checks if the value of the field is `_3_SCLK`" ] # [ inline ] pub fn is_3_sclk ( & self ) -> bool { * self == WKUPDBCR :: _3_SCLK } # [ doc = "Checks if the value of the field is `_32_SCLK`" ] # [ inline ] pub fn is_32_sclk ( & self ) -> bool { * self == WKUPDBCR :: _32_SCLK } # [ doc = "Checks if the value of the field is `_512_SCLK`" ] # [ inline ] pub fn is_512_sclk ( & self ) -> bool { * self == WKUPDBCR :: _512_SCLK } # [ doc = "Checks if the value of the field is `_4096_SCLK`" ] # [ inline ] pub fn is_4096_sclk ( & self ) -> bool { * self == WKUPDBCR :: _4096_SCLK } # [ doc = "Checks if the value of the field is `_32768_SCLK`" ] # [ inline ] pub fn is_32768_sclk ( & self ) -> bool { * self == WKUPDBCR :: _32768_SCLK } } # [ doc = "Values that can be written to the field `FWUPEN`" ] pub enum FWUPENW { # [ doc = "the Force Wake-up pin has no wake-up effect." ] NOT_ENABLE , # [ doc = "the Force Wake-up pin low forces the wake-up of the core power supply." ] ENABLE } impl FWUPENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { FWUPENW :: NOT_ENABLE => false , FWUPENW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _FWUPENW < 'a > { w : & 'a mut W , } impl < 'a > _FWUPENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FWUPENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the Force Wake-up pin has no wake-up effect." ] # [ inline ] pub fn not_enable ( self ) -> & 'a mut W { self . variant ( FWUPENW :: NOT_ENABLE ) } # [ doc = "the Force Wake-up pin low forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( FWUPENW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `SMEN`" ] pub enum SMENW { # [ doc = "the supply monitor detection has no wake-up effect." ] NOT_ENABLE , # [ doc = "the supply monitor detection forces the wake-up of the core power supply." ] ENABLE } impl SMENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { SMENW :: NOT_ENABLE => false , SMENW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _SMENW < 'a > { w : & 'a mut W , } impl < 'a > _SMENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : SMENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the supply monitor detection has no wake-up effect." ] # [ inline ] pub fn not_enable ( self ) -> & 'a mut W { self . variant ( SMENW :: NOT_ENABLE ) } # [ doc = "the supply monitor detection forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( SMENW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `RTTEN`" ] pub enum RTTENW { # [ doc = "the RTT alarm signal has no wake-up effect." ] NOT_ENABLE , # [ doc = "the RTT alarm signal forces the wake-up of the core power supply." ] ENABLE } impl RTTENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { RTTENW :: NOT_ENABLE => false , RTTENW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _RTTENW < 'a > { w : & 'a mut W , } impl < 'a > _RTTENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RTTENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the RTT alarm signal has no wake-up effect." ] # [ inline ] pub fn not_enable ( self ) -> & 'a mut W { self . variant ( RTTENW :: NOT_ENABLE ) } # [ doc = "the RTT alarm signal forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( RTTENW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `RTCEN`" ] pub enum RTCENW { # [ doc = "the RTC alarm signal has no wake-up effect." ] NOT_ENABLE , # [ doc = "the RTC alarm signal forces the wake-up of the core power supply." ] ENABLE } impl RTCENW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { RTCENW :: NOT_ENABLE => false , RTCENW :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _RTCENW < 'a > { w : & 'a mut W , } impl < 'a > _RTCENW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : RTCENW ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the RTC alarm signal has no wake-up effect." ] # [ inline ] pub fn not_enable ( self ) -> & 'a mut W { self . variant ( RTCENW :: NOT_ENABLE ) } # [ doc = "the RTC alarm signal forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( RTCENW :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `FWUPDBC`" ] pub enum FWUPDBCW { # [ doc = "Immediate, no debouncing, detected active at least on one Slow Clock edge." ] IMMEDIATE , # [ doc = "FWUP shall be low for at least 3 SLCK periods" ] _3_SCLK , # [ doc = "FWUP shall be low for at least 32 SLCK periods" ] _32_SCLK , # [ doc = "FWUP shall be low for at least 512 SLCK periods" ] _512_SCLK , # [ doc = "FWUP shall be low for at least 4,096 SLCK periods" ] _4096_SCLK , # [ doc = "FWUP shall be low for at least 32,768 SLCK periods" ] _32768_SCLK } impl FWUPDBCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { FWUPDBCW :: IMMEDIATE => 0 , FWUPDBCW :: _3_SCLK => 1 , FWUPDBCW :: _32_SCLK => 2 , FWUPDBCW :: _512_SCLK => 3 , FWUPDBCW :: _4096_SCLK => 4 , FWUPDBCW :: _32768_SCLK => 5 } } } # [ doc = r" Proxy" ] pub struct _FWUPDBCW < 'a > { w : & 'a mut W , } impl < 'a > _FWUPDBCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : FWUPDBCW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Immediate, no debouncing, detected active at least on one Slow Clock edge." ] # [ inline ] pub fn immediate ( self ) -> & 'a mut W { self . variant ( FWUPDBCW :: IMMEDIATE ) } # [ doc = "FWUP shall be low for at least 3 SLCK periods" ] # [ inline ] pub fn _3_sclk ( self ) -> & 'a mut W { self . variant ( FWUPDBCW :: _3_SCLK ) } # [ doc = "FWUP shall be low for at least 32 SLCK periods" ] # [ inline ] pub fn _32_sclk ( self ) -> & 'a mut W { self . variant ( FWUPDBCW :: _32_SCLK ) } # [ doc = "FWUP shall be low for at least 512 SLCK periods" ] # [ inline ] pub fn _512_sclk ( self ) -> & 'a mut W { self . variant ( FWUPDBCW :: _512_SCLK ) } # [ doc = "FWUP shall be low for at least 4,096 SLCK periods" ] # [ inline ] pub fn _4096_sclk ( self ) -> & 'a mut W { self . variant ( FWUPDBCW :: _4096_SCLK ) } # [ doc = "FWUP shall be low for at least 32,768 SLCK periods" ] # [ inline ] pub fn _32768_sclk ( self ) -> & 'a mut W { self . variant ( FWUPDBCW :: _32768_SCLK ) } # [ 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 = "Values that can be written to the field `WKUPDBC`" ] pub enum WKUPDBCW { # [ doc = "Immediate, no debouncing, detected active at least on one Slow Clock edge." ] IMMEDIATE , # [ doc = "WKUPx shall be in its active state for at least 3 SLCK periods" ] _3_SCLK , # [ doc = "WKUPx shall be in its active state for at least 32 SLCK periods" ] _32_SCLK , # [ doc = "WKUPx shall be in its active state for at least 512 SLCK periods" ] _512_SCLK , # [ doc = "WKUPx shall be in its active state for at least 4,096 SLCK periods" ] _4096_SCLK , # [ doc = "WKUPx shall be in its active state for at least 32,768 SLCK periods" ] _32768_SCLK } impl WKUPDBCW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { WKUPDBCW :: IMMEDIATE => 0 , WKUPDBCW :: _3_SCLK => 1 , WKUPDBCW :: _32_SCLK => 2 , WKUPDBCW :: _512_SCLK => 3 , WKUPDBCW :: _4096_SCLK => 4 , WKUPDBCW :: _32768_SCLK => 5 } } } # [ doc = r" Proxy" ] pub struct _WKUPDBCW < 'a > { w : & 'a mut W , } impl < 'a > _WKUPDBCW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPDBCW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Immediate, no debouncing, detected active at least on one Slow Clock edge." ] # [ inline ] pub fn immediate ( self ) -> & 'a mut W { self . variant ( WKUPDBCW :: IMMEDIATE ) } # [ doc = "WKUPx shall be in its active state for at least 3 SLCK periods" ] # [ inline ] pub fn _3_sclk ( self ) -> & 'a mut W { self . variant ( WKUPDBCW :: _3_SCLK ) } # [ doc = "WKUPx shall be in its active state for at least 32 SLCK periods" ] # [ inline ] pub fn _32_sclk ( self ) -> & 'a mut W { self . variant ( WKUPDBCW :: _32_SCLK ) } # [ doc = "WKUPx shall be in its active state for at least 512 SLCK periods" ] # [ inline ] pub fn _512_sclk ( self ) -> & 'a mut W { self . variant ( WKUPDBCW :: _512_SCLK ) } # [ doc = "WKUPx shall be in its active state for at least 4,096 SLCK periods" ] # [ inline ] pub fn _4096_sclk ( self ) -> & 'a mut W { self . variant ( WKUPDBCW :: _4096_SCLK ) } # [ doc = "WKUPx shall be in its active state for at least 32,768 SLCK periods" ] # [ inline ] pub fn _32768_sclk ( self ) -> & 'a mut W { self . variant ( WKUPDBCW :: _32768_SCLK ) } # [ 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 } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Force Wake-up Enable" ] # [ inline ] pub fn fwupen ( & self ) -> FWUPENR { FWUPENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Supply Monitor Wake-up Enable" ] # [ inline ] pub fn smen ( & self ) -> SMENR { SMENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 2 - Real Time Timer Wake-up Enable" ] # [ inline ] pub fn rtten ( & self ) -> RTTENR { RTTENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 3 - Real Time Clock Wake-up Enable" ] # [ inline ] pub fn rtcen ( & self ) -> RTCENR { RTCENR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bits 8:10 - Force Wake-up Debouncer Period" ] # [ inline ] pub fn fwupdbc ( & self ) -> FWUPDBCR { FWUPDBCR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 12:14 - Wake-up Inputs Debouncer Period" ] # [ inline ] pub fn wkupdbc ( & self ) -> WKUPDBCR { WKUPDBCR :: _from ( { const MASK : u8 = 0x07 ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 - Force Wake-up Enable" ] # [ inline ] pub fn fwupen ( & mut self ) -> _FWUPENW { _FWUPENW { w : self } } # [ doc = "Bit 1 - Supply Monitor Wake-up Enable" ] # [ inline ] pub fn smen ( & mut self ) -> _SMENW { _SMENW { w : self } } # [ doc = "Bit 2 - Real Time Timer Wake-up Enable" ] # [ inline ] pub fn rtten ( & mut self ) -> _RTTENW { _RTTENW { w : self } } # [ doc = "Bit 3 - Real Time Clock Wake-up Enable" ] # [ inline ] pub fn rtcen ( & mut self ) -> _RTCENW { _RTCENW { w : self } } # [ doc = "Bits 8:10 - Force Wake-up Debouncer Period" ] # [ inline ] pub fn fwupdbc ( & mut self ) -> _FWUPDBCW { _FWUPDBCW { w : self } } # [ doc = "Bits 12:14 - Wake-up Inputs Debouncer Period" ] # [ inline ] pub fn wkupdbc ( & mut self ) -> _WKUPDBCW { _WKUPDBCW { w : self } } } } # [ doc = "Supply Controller Wake-up Inputs Register" ] pub struct WUIR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Supply Controller Wake-up Inputs Register" ] pub mod wuir { # [ 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 :: WUIR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 = "Possible values of the field `WKUPEN0`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN0R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN0R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN0R :: DISABLE => false , WKUPEN0R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN0R { match value { false => WKUPEN0R :: DISABLE , true => WKUPEN0R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN0R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN0R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN1`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN1R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN1R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN1R :: DISABLE => false , WKUPEN1R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN1R { match value { false => WKUPEN1R :: DISABLE , true => WKUPEN1R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN1R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN1R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN2`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN2R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN2R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN2R :: DISABLE => false , WKUPEN2R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN2R { match value { false => WKUPEN2R :: DISABLE , true => WKUPEN2R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN2R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN2R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN3`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN3R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN3R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN3R :: DISABLE => false , WKUPEN3R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN3R { match value { false => WKUPEN3R :: DISABLE , true => WKUPEN3R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN3R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN3R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN4`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN4R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN4R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN4R :: DISABLE => false , WKUPEN4R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN4R { match value { false => WKUPEN4R :: DISABLE , true => WKUPEN4R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN4R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN4R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN5`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN5R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN5R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN5R :: DISABLE => false , WKUPEN5R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN5R { match value { false => WKUPEN5R :: DISABLE , true => WKUPEN5R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN5R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN5R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN6`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN6R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN6R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN6R :: DISABLE => false , WKUPEN6R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN6R { match value { false => WKUPEN6R :: DISABLE , true => WKUPEN6R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN6R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN6R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN7`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN7R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN7R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN7R :: DISABLE => false , WKUPEN7R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN7R { match value { false => WKUPEN7R :: DISABLE , true => WKUPEN7R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN7R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN7R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN8`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN8R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN8R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN8R :: DISABLE => false , WKUPEN8R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN8R { match value { false => WKUPEN8R :: DISABLE , true => WKUPEN8R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN8R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN8R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN9`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN9R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN9R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN9R :: DISABLE => false , WKUPEN9R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN9R { match value { false => WKUPEN9R :: DISABLE , true => WKUPEN9R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN9R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN9R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN10`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN10R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN10R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN10R :: DISABLE => false , WKUPEN10R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN10R { match value { false => WKUPEN10R :: DISABLE , true => WKUPEN10R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN10R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN10R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN11`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN11R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN11R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN11R :: DISABLE => false , WKUPEN11R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN11R { match value { false => WKUPEN11R :: DISABLE , true => WKUPEN11R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN11R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN11R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN12`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN12R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN12R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN12R :: DISABLE => false , WKUPEN12R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN12R { match value { false => WKUPEN12R :: DISABLE , true => WKUPEN12R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN12R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN12R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN13`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN13R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN13R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN13R :: DISABLE => false , WKUPEN13R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN13R { match value { false => WKUPEN13R :: DISABLE , true => WKUPEN13R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN13R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN13R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN14`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN14R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN14R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN14R :: DISABLE => false , WKUPEN14R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN14R { match value { false => WKUPEN14R :: DISABLE , true => WKUPEN14R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN14R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN14R :: ENABLE } } # [ doc = "Possible values of the field `WKUPEN15`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPEN15R { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN15R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPEN15R :: DISABLE => false , WKUPEN15R :: ENABLE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPEN15R { match value { false => WKUPEN15R :: DISABLE , true => WKUPEN15R :: ENABLE , } } # [ doc = "Checks if the value of the field is `DISABLE`" ] # [ inline ] pub fn is_disable ( & self ) -> bool { * self == WKUPEN15R :: DISABLE } # [ doc = "Checks if the value of the field is `ENABLE`" ] # [ inline ] pub fn is_enable ( & self ) -> bool { * self == WKUPEN15R :: ENABLE } } # [ doc = "Possible values of the field `WKUPT0`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT0R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT0R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT0R :: HIGH_TO_LOW => false , WKUPT0R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT0R { match value { false => WKUPT0R :: HIGH_TO_LOW , true => WKUPT0R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT0R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT0R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT1`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT1R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT1R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT1R :: HIGH_TO_LOW => false , WKUPT1R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT1R { match value { false => WKUPT1R :: HIGH_TO_LOW , true => WKUPT1R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT1R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT1R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT2`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT2R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT2R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT2R :: HIGH_TO_LOW => false , WKUPT2R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT2R { match value { false => WKUPT2R :: HIGH_TO_LOW , true => WKUPT2R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT2R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT2R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT3`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT3R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT3R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT3R :: HIGH_TO_LOW => false , WKUPT3R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT3R { match value { false => WKUPT3R :: HIGH_TO_LOW , true => WKUPT3R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT3R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT3R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT4`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT4R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT4R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT4R :: HIGH_TO_LOW => false , WKUPT4R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT4R { match value { false => WKUPT4R :: HIGH_TO_LOW , true => WKUPT4R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT4R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT4R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT5`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT5R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT5R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT5R :: HIGH_TO_LOW => false , WKUPT5R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT5R { match value { false => WKUPT5R :: HIGH_TO_LOW , true => WKUPT5R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT5R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT5R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT6`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT6R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT6R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT6R :: HIGH_TO_LOW => false , WKUPT6R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT6R { match value { false => WKUPT6R :: HIGH_TO_LOW , true => WKUPT6R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT6R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT6R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT7`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT7R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT7R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT7R :: HIGH_TO_LOW => false , WKUPT7R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT7R { match value { false => WKUPT7R :: HIGH_TO_LOW , true => WKUPT7R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT7R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT7R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT8`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT8R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT8R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT8R :: HIGH_TO_LOW => false , WKUPT8R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT8R { match value { false => WKUPT8R :: HIGH_TO_LOW , true => WKUPT8R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT8R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT8R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT9`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT9R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT9R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT9R :: HIGH_TO_LOW => false , WKUPT9R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT9R { match value { false => WKUPT9R :: HIGH_TO_LOW , true => WKUPT9R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT9R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT9R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT10`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT10R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT10R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT10R :: HIGH_TO_LOW => false , WKUPT10R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT10R { match value { false => WKUPT10R :: HIGH_TO_LOW , true => WKUPT10R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT10R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT10R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT11`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT11R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT11R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT11R :: HIGH_TO_LOW => false , WKUPT11R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT11R { match value { false => WKUPT11R :: HIGH_TO_LOW , true => WKUPT11R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT11R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT11R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT12`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT12R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT12R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT12R :: HIGH_TO_LOW => false , WKUPT12R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT12R { match value { false => WKUPT12R :: HIGH_TO_LOW , true => WKUPT12R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT12R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT12R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT13`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT13R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT13R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT13R :: HIGH_TO_LOW => false , WKUPT13R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT13R { match value { false => WKUPT13R :: HIGH_TO_LOW , true => WKUPT13R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT13R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT13R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT14`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT14R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT14R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT14R :: HIGH_TO_LOW => false , WKUPT14R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT14R { match value { false => WKUPT14R :: HIGH_TO_LOW , true => WKUPT14R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT14R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT14R :: LOW_TO_HIGH } } # [ doc = "Possible values of the field `WKUPT15`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPT15R { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT15R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPT15R :: HIGH_TO_LOW => false , WKUPT15R :: LOW_TO_HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPT15R { match value { false => WKUPT15R :: HIGH_TO_LOW , true => WKUPT15R :: LOW_TO_HIGH , } } # [ doc = "Checks if the value of the field is `HIGH_TO_LOW`" ] # [ inline ] pub fn is_high_to_low ( & self ) -> bool { * self == WKUPT15R :: HIGH_TO_LOW } # [ doc = "Checks if the value of the field is `LOW_TO_HIGH`" ] # [ inline ] pub fn is_low_to_high ( & self ) -> bool { * self == WKUPT15R :: LOW_TO_HIGH } } # [ doc = "Values that can be written to the field `WKUPEN0`" ] pub enum WKUPEN0W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN0W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN0W :: DISABLE => false , WKUPEN0W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN0W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN0W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN0W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN0W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN0W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN1`" ] pub enum WKUPEN1W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN1W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN1W :: DISABLE => false , WKUPEN1W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN1W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN1W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN1W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN1W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN1W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN2`" ] pub enum WKUPEN2W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN2W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN2W :: DISABLE => false , WKUPEN2W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN2W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN2W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN2W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN2W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN2W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN3`" ] pub enum WKUPEN3W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN3W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN3W :: DISABLE => false , WKUPEN3W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN3W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN3W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN3W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN3W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN3W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN4`" ] pub enum WKUPEN4W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN4W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN4W :: DISABLE => false , WKUPEN4W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN4W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN4W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN4W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN4W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN4W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN5`" ] pub enum WKUPEN5W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN5W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN5W :: DISABLE => false , WKUPEN5W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN5W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN5W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN5W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN5W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN5W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN6`" ] pub enum WKUPEN6W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN6W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN6W :: DISABLE => false , WKUPEN6W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN6W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN6W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN6W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN6W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN6W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN7`" ] pub enum WKUPEN7W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN7W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN7W :: DISABLE => false , WKUPEN7W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN7W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN7W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN7W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN7W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN7W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN8`" ] pub enum WKUPEN8W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN8W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN8W :: DISABLE => false , WKUPEN8W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN8W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN8W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN8W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN8W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN8W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN9`" ] pub enum WKUPEN9W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN9W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN9W :: DISABLE => false , WKUPEN9W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN9W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN9W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN9W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN9W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN9W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN10`" ] pub enum WKUPEN10W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN10W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN10W :: DISABLE => false , WKUPEN10W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN10W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN10W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN10W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN10W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN10W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN11`" ] pub enum WKUPEN11W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN11W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN11W :: DISABLE => false , WKUPEN11W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN11W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN11W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN11W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN11W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN11W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN12`" ] pub enum WKUPEN12W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN12W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN12W :: DISABLE => false , WKUPEN12W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN12W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN12W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN12W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN12W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN12W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN13`" ] pub enum WKUPEN13W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN13W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN13W :: DISABLE => false , WKUPEN13W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN13W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN13W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN13W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN13W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN13W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN14`" ] pub enum WKUPEN14W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN14W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN14W :: DISABLE => false , WKUPEN14W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN14W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN14W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN14W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN14W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN14W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPEN15`" ] pub enum WKUPEN15W { # [ doc = "the corresponding wake-up input has no wake-up effect." ] DISABLE , # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] ENABLE } impl WKUPEN15W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPEN15W :: DISABLE => false , WKUPEN15W :: ENABLE => true } } } # [ doc = r" Proxy" ] pub struct _WKUPEN15W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPEN15W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPEN15W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "the corresponding wake-up input has no wake-up effect." ] # [ inline ] pub fn disable ( self ) -> & 'a mut W { self . variant ( WKUPEN15W :: DISABLE ) } # [ doc = "the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn enable ( self ) -> & 'a mut W { self . variant ( WKUPEN15W :: ENABLE ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT0`" ] pub enum WKUPT0W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT0W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT0W :: HIGH_TO_LOW => false , WKUPT0W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT0W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT0W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT0W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT0W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT0W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT1`" ] pub enum WKUPT1W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT1W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT1W :: HIGH_TO_LOW => false , WKUPT1W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT1W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT1W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT1W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT1W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT1W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT2`" ] pub enum WKUPT2W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT2W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT2W :: HIGH_TO_LOW => false , WKUPT2W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT2W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT2W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT2W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT2W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT2W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT3`" ] pub enum WKUPT3W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT3W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT3W :: HIGH_TO_LOW => false , WKUPT3W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT3W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT3W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT3W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT3W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT3W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT4`" ] pub enum WKUPT4W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT4W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT4W :: HIGH_TO_LOW => false , WKUPT4W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT4W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT4W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT4W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT4W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT4W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT5`" ] pub enum WKUPT5W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT5W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT5W :: HIGH_TO_LOW => false , WKUPT5W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT5W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT5W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT5W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT5W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT5W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT6`" ] pub enum WKUPT6W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT6W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT6W :: HIGH_TO_LOW => false , WKUPT6W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT6W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT6W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT6W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT6W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT6W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT7`" ] pub enum WKUPT7W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT7W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT7W :: HIGH_TO_LOW => false , WKUPT7W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT7W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT7W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT7W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT7W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT7W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT8`" ] pub enum WKUPT8W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT8W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT8W :: HIGH_TO_LOW => false , WKUPT8W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT8W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT8W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT8W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT8W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT8W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT9`" ] pub enum WKUPT9W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT9W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT9W :: HIGH_TO_LOW => false , WKUPT9W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT9W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT9W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT9W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT9W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT9W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT10`" ] pub enum WKUPT10W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT10W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT10W :: HIGH_TO_LOW => false , WKUPT10W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT10W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT10W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT10W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT10W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT10W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT11`" ] pub enum WKUPT11W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT11W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT11W :: HIGH_TO_LOW => false , WKUPT11W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT11W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT11W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT11W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT11W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT11W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT12`" ] pub enum WKUPT12W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT12W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT12W :: HIGH_TO_LOW => false , WKUPT12W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT12W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT12W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT12W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT12W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT12W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT13`" ] pub enum WKUPT13W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT13W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT13W :: HIGH_TO_LOW => false , WKUPT13W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT13W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT13W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT13W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT13W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT13W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT14`" ] pub enum WKUPT14W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT14W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT14W :: HIGH_TO_LOW => false , WKUPT14W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT14W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT14W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT14W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT14W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT14W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WKUPT15`" ] pub enum WKUPT15W { # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] HIGH_TO_LOW , # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] LOW_TO_HIGH } impl WKUPT15W { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> bool { match * self { WKUPT15W :: HIGH_TO_LOW => false , WKUPT15W :: LOW_TO_HIGH => true } } } # [ doc = r" Proxy" ] pub struct _WKUPT15W < 'a > { w : & 'a mut W , } impl < 'a > _WKUPT15W < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WKUPT15W ) -> & 'a mut W { { self . bit ( variant . _bits ( ) ) } } # [ doc = "a high to low level transition for a period defined by WKUPDBC on the corresponding wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn high_to_low ( self ) -> & 'a mut W { self . variant ( WKUPT15W :: HIGH_TO_LOW ) } # [ doc = "a low to high level transition for a period defined by WKUPDBC on the correspond-ing wake-up input forces the wake-up of the core power supply." ] # [ inline ] pub fn low_to_high ( self ) -> & 'a mut W { self . variant ( WKUPT15W :: LOW_TO_HIGH ) } # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - Wake-up Input Enable 0" ] # [ inline ] pub fn wkupen0 ( & self ) -> WKUPEN0R { WKUPEN0R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Wake-up Input Enable 1" ] # [ inline ] pub fn wkupen1 ( & self ) -> WKUPEN1R { WKUPEN1R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 2 - Wake-up Input Enable 2" ] # [ inline ] pub fn wkupen2 ( & self ) -> WKUPEN2R { WKUPEN2R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 3 - Wake-up Input Enable 3" ] # [ inline ] pub fn wkupen3 ( & self ) -> WKUPEN3R { WKUPEN3R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 4 - Wake-up Input Enable 4" ] # [ inline ] pub fn wkupen4 ( & self ) -> WKUPEN4R { WKUPEN4R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 5 - Wake-up Input Enable 5" ] # [ inline ] pub fn wkupen5 ( & self ) -> WKUPEN5R { WKUPEN5R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 6 - Wake-up Input Enable 6" ] # [ inline ] pub fn wkupen6 ( & self ) -> WKUPEN6R { WKUPEN6R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 7 - Wake-up Input Enable 7" ] # [ inline ] pub fn wkupen7 ( & self ) -> WKUPEN7R { WKUPEN7R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 8 - Wake-up Input Enable 8" ] # [ inline ] pub fn wkupen8 ( & self ) -> WKUPEN8R { WKUPEN8R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 9 - Wake-up Input Enable 9" ] # [ inline ] pub fn wkupen9 ( & self ) -> WKUPEN9R { WKUPEN9R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 9 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 10 - Wake-up Input Enable 10" ] # [ inline ] pub fn wkupen10 ( & self ) -> WKUPEN10R { WKUPEN10R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 10 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 11 - Wake-up Input Enable 11" ] # [ inline ] pub fn wkupen11 ( & self ) -> WKUPEN11R { WKUPEN11R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 11 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 12 - Wake-up Input Enable 12" ] # [ inline ] pub fn wkupen12 ( & self ) -> WKUPEN12R { WKUPEN12R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 13 - Wake-up Input Enable 13" ] # [ inline ] pub fn wkupen13 ( & self ) -> WKUPEN13R { WKUPEN13R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 14 - Wake-up Input Enable 14" ] # [ inline ] pub fn wkupen14 ( & self ) -> WKUPEN14R { WKUPEN14R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 15 - Wake-up Input Enable 15" ] # [ inline ] pub fn wkupen15 ( & self ) -> WKUPEN15R { WKUPEN15R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - Wake-up Input Type 0" ] # [ inline ] pub fn wkupt0 ( & self ) -> WKUPT0R { WKUPT0R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 17 - Wake-up Input Type 1" ] # [ inline ] pub fn wkupt1 ( & self ) -> WKUPT1R { WKUPT1R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 18 - Wake-up Input Type 2" ] # [ inline ] pub fn wkupt2 ( & self ) -> WKUPT2R { WKUPT2R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 19 - Wake-up Input Type 3" ] # [ inline ] pub fn wkupt3 ( & self ) -> WKUPT3R { WKUPT3R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - Wake-up Input Type 4" ] # [ inline ] pub fn wkupt4 ( & self ) -> WKUPT4R { WKUPT4R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - Wake-up Input Type 5" ] # [ inline ] pub fn wkupt5 ( & self ) -> WKUPT5R { WKUPT5R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - Wake-up Input Type 6" ] # [ inline ] pub fn wkupt6 ( & self ) -> WKUPT6R { WKUPT6R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 23 - Wake-up Input Type 7" ] # [ inline ] pub fn wkupt7 ( & self ) -> WKUPT7R { WKUPT7R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 24 - Wake-up Input Type 8" ] # [ inline ] pub fn wkupt8 ( & self ) -> WKUPT8R { WKUPT8R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 25 - Wake-up Input Type 9" ] # [ inline ] pub fn wkupt9 ( & self ) -> WKUPT9R { WKUPT9R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 26 - Wake-up Input Type 10" ] # [ inline ] pub fn wkupt10 ( & self ) -> WKUPT10R { WKUPT10R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 27 - Wake-up Input Type 11" ] # [ inline ] pub fn wkupt11 ( & self ) -> WKUPT11R { WKUPT11R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 28 - Wake-up Input Type 12" ] # [ inline ] pub fn wkupt12 ( & self ) -> WKUPT12R { WKUPT12R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 29 - Wake-up Input Type 13" ] # [ inline ] pub fn wkupt13 ( & self ) -> WKUPT13R { WKUPT13R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 30 - Wake-up Input Type 14" ] # [ inline ] pub fn wkupt14 ( & self ) -> WKUPT14R { WKUPT14R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 31 - Wake-up Input Type 15" ] # [ inline ] pub fn wkupt15 ( & self ) -> WKUPT15R { WKUPT15R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } 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 - Wake-up Input Enable 0" ] # [ inline ] pub fn wkupen0 ( & mut self ) -> _WKUPEN0W { _WKUPEN0W { w : self } } # [ doc = "Bit 1 - Wake-up Input Enable 1" ] # [ inline ] pub fn wkupen1 ( & mut self ) -> _WKUPEN1W { _WKUPEN1W { w : self } } # [ doc = "Bit 2 - Wake-up Input Enable 2" ] # [ inline ] pub fn wkupen2 ( & mut self ) -> _WKUPEN2W { _WKUPEN2W { w : self } } # [ doc = "Bit 3 - Wake-up Input Enable 3" ] # [ inline ] pub fn wkupen3 ( & mut self ) -> _WKUPEN3W { _WKUPEN3W { w : self } } # [ doc = "Bit 4 - Wake-up Input Enable 4" ] # [ inline ] pub fn wkupen4 ( & mut self ) -> _WKUPEN4W { _WKUPEN4W { w : self } } # [ doc = "Bit 5 - Wake-up Input Enable 5" ] # [ inline ] pub fn wkupen5 ( & mut self ) -> _WKUPEN5W { _WKUPEN5W { w : self } } # [ doc = "Bit 6 - Wake-up Input Enable 6" ] # [ inline ] pub fn wkupen6 ( & mut self ) -> _WKUPEN6W { _WKUPEN6W { w : self } } # [ doc = "Bit 7 - Wake-up Input Enable 7" ] # [ inline ] pub fn wkupen7 ( & mut self ) -> _WKUPEN7W { _WKUPEN7W { w : self } } # [ doc = "Bit 8 - Wake-up Input Enable 8" ] # [ inline ] pub fn wkupen8 ( & mut self ) -> _WKUPEN8W { _WKUPEN8W { w : self } } # [ doc = "Bit 9 - Wake-up Input Enable 9" ] # [ inline ] pub fn wkupen9 ( & mut self ) -> _WKUPEN9W { _WKUPEN9W { w : self } } # [ doc = "Bit 10 - Wake-up Input Enable 10" ] # [ inline ] pub fn wkupen10 ( & mut self ) -> _WKUPEN10W { _WKUPEN10W { w : self } } # [ doc = "Bit 11 - Wake-up Input Enable 11" ] # [ inline ] pub fn wkupen11 ( & mut self ) -> _WKUPEN11W { _WKUPEN11W { w : self } } # [ doc = "Bit 12 - Wake-up Input Enable 12" ] # [ inline ] pub fn wkupen12 ( & mut self ) -> _WKUPEN12W { _WKUPEN12W { w : self } } # [ doc = "Bit 13 - Wake-up Input Enable 13" ] # [ inline ] pub fn wkupen13 ( & mut self ) -> _WKUPEN13W { _WKUPEN13W { w : self } } # [ doc = "Bit 14 - Wake-up Input Enable 14" ] # [ inline ] pub fn wkupen14 ( & mut self ) -> _WKUPEN14W { _WKUPEN14W { w : self } } # [ doc = "Bit 15 - Wake-up Input Enable 15" ] # [ inline ] pub fn wkupen15 ( & mut self ) -> _WKUPEN15W { _WKUPEN15W { w : self } } # [ doc = "Bit 16 - Wake-up Input Type 0" ] # [ inline ] pub fn wkupt0 ( & mut self ) -> _WKUPT0W { _WKUPT0W { w : self } } # [ doc = "Bit 17 - Wake-up Input Type 1" ] # [ inline ] pub fn wkupt1 ( & mut self ) -> _WKUPT1W { _WKUPT1W { w : self } } # [ doc = "Bit 18 - Wake-up Input Type 2" ] # [ inline ] pub fn wkupt2 ( & mut self ) -> _WKUPT2W { _WKUPT2W { w : self } } # [ doc = "Bit 19 - Wake-up Input Type 3" ] # [ inline ] pub fn wkupt3 ( & mut self ) -> _WKUPT3W { _WKUPT3W { w : self } } # [ doc = "Bit 20 - Wake-up Input Type 4" ] # [ inline ] pub fn wkupt4 ( & mut self ) -> _WKUPT4W { _WKUPT4W { w : self } } # [ doc = "Bit 21 - Wake-up Input Type 5" ] # [ inline ] pub fn wkupt5 ( & mut self ) -> _WKUPT5W { _WKUPT5W { w : self } } # [ doc = "Bit 22 - Wake-up Input Type 6" ] # [ inline ] pub fn wkupt6 ( & mut self ) -> _WKUPT6W { _WKUPT6W { w : self } } # [ doc = "Bit 23 - Wake-up Input Type 7" ] # [ inline ] pub fn wkupt7 ( & mut self ) -> _WKUPT7W { _WKUPT7W { w : self } } # [ doc = "Bit 24 - Wake-up Input Type 8" ] # [ inline ] pub fn wkupt8 ( & mut self ) -> _WKUPT8W { _WKUPT8W { w : self } } # [ doc = "Bit 25 - Wake-up Input Type 9" ] # [ inline ] pub fn wkupt9 ( & mut self ) -> _WKUPT9W { _WKUPT9W { w : self } } # [ doc = "Bit 26 - Wake-up Input Type 10" ] # [ inline ] pub fn wkupt10 ( & mut self ) -> _WKUPT10W { _WKUPT10W { w : self } } # [ doc = "Bit 27 - Wake-up Input Type 11" ] # [ inline ] pub fn wkupt11 ( & mut self ) -> _WKUPT11W { _WKUPT11W { w : self } } # [ doc = "Bit 28 - Wake-up Input Type 12" ] # [ inline ] pub fn wkupt12 ( & mut self ) -> _WKUPT12W { _WKUPT12W { w : self } } # [ doc = "Bit 29 - Wake-up Input Type 13" ] # [ inline ] pub fn wkupt13 ( & mut self ) -> _WKUPT13W { _WKUPT13W { w : self } } # [ doc = "Bit 30 - Wake-up Input Type 14" ] # [ inline ] pub fn wkupt14 ( & mut self ) -> _WKUPT14W { _WKUPT14W { w : self } } # [ doc = "Bit 31 - Wake-up Input Type 15" ] # [ inline ] pub fn wkupt15 ( & mut self ) -> _WKUPT15W { _WKUPT15W { w : self } } } } # [ doc = "Supply Controller Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Supply Controller 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 = "Possible values of the field `FWUPS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FWUPSR { # [ doc = "no wake-up due to the assertion of the FWUP pin has occurred since the last read of SUPC_SR." ] NO , # [ doc = "at least one wake-up due to the assertion of the FWUP pin has occurred since the last read of SUPC_SR." ] PRESENT } impl FWUPSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { FWUPSR :: NO => false , FWUPSR :: PRESENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> FWUPSR { match value { false => FWUPSR :: NO , true => FWUPSR :: PRESENT , } } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == FWUPSR :: NO } # [ doc = "Checks if the value of the field is `PRESENT`" ] # [ inline ] pub fn is_present ( & self ) -> bool { * self == FWUPSR :: PRESENT } } # [ doc = "Possible values of the field `WKUPS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPSR { # [ doc = "no wake-up due to the assertion of the WKUP pins has occurred since the last read of SUPC_SR." ] NO , # [ doc = "at least one wake-up due to the assertion of the WKUP pins has occurred since the last read of SUPC_SR." ] PRESENT } impl WKUPSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPSR :: NO => false , WKUPSR :: PRESENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPSR { match value { false => WKUPSR :: NO , true => WKUPSR :: PRESENT , } } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == WKUPSR :: NO } # [ doc = "Checks if the value of the field is `PRESENT`" ] # [ inline ] pub fn is_present ( & self ) -> bool { * self == WKUPSR :: PRESENT } } # [ doc = "Possible values of the field `SMWS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMWSR { # [ doc = "no wake-up due to a supply monitor detection has occurred since the last read of SUPC_SR." ] NO , # [ doc = "at least one wake-up due to a supply monitor detection has occurred since the last read of SUPC_SR." ] PRESENT } impl SMWSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMWSR :: NO => false , SMWSR :: PRESENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMWSR { match value { false => SMWSR :: NO , true => SMWSR :: PRESENT , } } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == SMWSR :: NO } # [ doc = "Checks if the value of the field is `PRESENT`" ] # [ inline ] pub fn is_present ( & self ) -> bool { * self == SMWSR :: PRESENT } } # [ doc = "Possible values of the field `BODRSTS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum BODRSTSR { # [ doc = "no core brownout rising edge event has been detected since the last read of the SUPC_SR." ] NO , # [ doc = "at least one brownout output rising edge event has been detected since the last read of the SUPC_SR." ] PRESENT } impl BODRSTSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { BODRSTSR :: NO => false , BODRSTSR :: PRESENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> BODRSTSR { match value { false => BODRSTSR :: NO , true => BODRSTSR :: PRESENT , } } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == BODRSTSR :: NO } # [ doc = "Checks if the value of the field is `PRESENT`" ] # [ inline ] pub fn is_present ( & self ) -> bool { * self == BODRSTSR :: PRESENT } } # [ doc = "Possible values of the field `SMRSTS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMRSTSR { # [ doc = "no supply monitor detection has generated a core reset since the last read of the SUPC_SR." ] NO , # [ doc = "at least one supply monitor detection has generated a core reset since the last read of the SUPC_SR." ] PRESENT } impl SMRSTSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMRSTSR :: NO => false , SMRSTSR :: PRESENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMRSTSR { match value { false => SMRSTSR :: NO , true => SMRSTSR :: PRESENT , } } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == SMRSTSR :: NO } # [ doc = "Checks if the value of the field is `PRESENT`" ] # [ inline ] pub fn is_present ( & self ) -> bool { * self == SMRSTSR :: PRESENT } } # [ doc = "Possible values of the field `SMS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMSR { # [ doc = "no supply monitor detection since the last read of SUPC_SR." ] NO , # [ doc = "at least one supply monitor detection since the last read of SUPC_SR." ] PRESENT } impl SMSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMSR :: NO => false , SMSR :: PRESENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMSR { match value { false => SMSR :: NO , true => SMSR :: PRESENT , } } # [ doc = "Checks if the value of the field is `NO`" ] # [ inline ] pub fn is_no ( & self ) -> bool { * self == SMSR :: NO } # [ doc = "Checks if the value of the field is `PRESENT`" ] # [ inline ] pub fn is_present ( & self ) -> bool { * self == SMSR :: PRESENT } } # [ doc = "Possible values of the field `SMOS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SMOSR { # [ doc = "the supply monitor detected VDDUTMI higher than its threshold at its last measurement." ] HIGH , # [ doc = "the supply monitor detected VDDUTMI lower than its threshold at its last measurement." ] LOW } impl SMOSR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SMOSR :: HIGH => false , SMOSR :: LOW => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SMOSR { match value { false => SMOSR :: HIGH , true => SMOSR :: LOW , } } # [ doc = "Checks if the value of the field is `HIGH`" ] # [ inline ] pub fn is_high ( & self ) -> bool { * self == SMOSR :: HIGH } # [ doc = "Checks if the value of the field is `LOW`" ] # [ inline ] pub fn is_low ( & self ) -> bool { * self == SMOSR :: LOW } } # [ doc = "Possible values of the field `OSCSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum OSCSELR { # [ doc = "the slow clock, SLCK is generated by the embedded 32-kHz RC oscillator." ] RC , # [ doc = "the slow clock, SLCK is generated by the 32-kHz crystal oscillator." ] CRYST } impl OSCSELR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { OSCSELR :: RC => false , OSCSELR :: CRYST => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> OSCSELR { match value { false => OSCSELR :: RC , true => OSCSELR :: CRYST , } } # [ doc = "Checks if the value of the field is `RC`" ] # [ inline ] pub fn is_rc ( & self ) -> bool { * self == OSCSELR :: RC } # [ doc = "Checks if the value of the field is `CRYST`" ] # [ inline ] pub fn is_cryst ( & self ) -> bool { * self == OSCSELR :: CRYST } } # [ doc = "Possible values of the field `FWUPIS`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum FWUPISR { # [ doc = "FWUP input is tied low." ] LOW , # [ doc = "FWUP input is tied high." ] HIGH } impl FWUPISR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { FWUPISR :: LOW => false , FWUPISR :: HIGH => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> FWUPISR { match value { false => FWUPISR :: LOW , true => FWUPISR :: HIGH , } } # [ doc = "Checks if the value of the field is `LOW`" ] # [ inline ] pub fn is_low ( & self ) -> bool { * self == FWUPISR :: LOW } # [ doc = "Checks if the value of the field is `HIGH`" ] # [ inline ] pub fn is_high ( & self ) -> bool { * self == FWUPISR :: HIGH } } # [ doc = "Possible values of the field `WKUPIS0`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS0R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS0R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS0R :: DIS => false , WKUPIS0R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS0R { match value { false => WKUPIS0R :: DIS , true => WKUPIS0R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS0R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS0R :: EN } } # [ doc = "Possible values of the field `WKUPIS1`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS1R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS1R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS1R :: DIS => false , WKUPIS1R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS1R { match value { false => WKUPIS1R :: DIS , true => WKUPIS1R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS1R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS1R :: EN } } # [ doc = "Possible values of the field `WKUPIS2`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS2R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS2R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS2R :: DIS => false , WKUPIS2R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS2R { match value { false => WKUPIS2R :: DIS , true => WKUPIS2R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS2R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS2R :: EN } } # [ doc = "Possible values of the field `WKUPIS3`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS3R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS3R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS3R :: DIS => false , WKUPIS3R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS3R { match value { false => WKUPIS3R :: DIS , true => WKUPIS3R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS3R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS3R :: EN } } # [ doc = "Possible values of the field `WKUPIS4`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS4R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS4R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS4R :: DIS => false , WKUPIS4R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS4R { match value { false => WKUPIS4R :: DIS , true => WKUPIS4R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS4R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS4R :: EN } } # [ doc = "Possible values of the field `WKUPIS5`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS5R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS5R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS5R :: DIS => false , WKUPIS5R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS5R { match value { false => WKUPIS5R :: DIS , true => WKUPIS5R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS5R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS5R :: EN } } # [ doc = "Possible values of the field `WKUPIS6`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS6R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS6R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS6R :: DIS => false , WKUPIS6R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS6R { match value { false => WKUPIS6R :: DIS , true => WKUPIS6R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS6R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS6R :: EN } } # [ doc = "Possible values of the field `WKUPIS7`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS7R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS7R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS7R :: DIS => false , WKUPIS7R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS7R { match value { false => WKUPIS7R :: DIS , true => WKUPIS7R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS7R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS7R :: EN } } # [ doc = "Possible values of the field `WKUPIS8`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS8R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS8R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS8R :: DIS => false , WKUPIS8R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS8R { match value { false => WKUPIS8R :: DIS , true => WKUPIS8R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS8R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS8R :: EN } } # [ doc = "Possible values of the field `WKUPIS9`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS9R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS9R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS9R :: DIS => false , WKUPIS9R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS9R { match value { false => WKUPIS9R :: DIS , true => WKUPIS9R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS9R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS9R :: EN } } # [ doc = "Possible values of the field `WKUPIS10`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS10R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS10R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS10R :: DIS => false , WKUPIS10R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS10R { match value { false => WKUPIS10R :: DIS , true => WKUPIS10R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS10R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS10R :: EN } } # [ doc = "Possible values of the field `WKUPIS11`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS11R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS11R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS11R :: DIS => false , WKUPIS11R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS11R { match value { false => WKUPIS11R :: DIS , true => WKUPIS11R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS11R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS11R :: EN } } # [ doc = "Possible values of the field `WKUPIS12`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS12R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS12R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS12R :: DIS => false , WKUPIS12R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS12R { match value { false => WKUPIS12R :: DIS , true => WKUPIS12R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS12R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS12R :: EN } } # [ doc = "Possible values of the field `WKUPIS13`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS13R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS13R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS13R :: DIS => false , WKUPIS13R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS13R { match value { false => WKUPIS13R :: DIS , true => WKUPIS13R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS13R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS13R :: EN } } # [ doc = "Possible values of the field `WKUPIS14`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS14R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS14R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS14R :: DIS => false , WKUPIS14R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS14R { match value { false => WKUPIS14R :: DIS , true => WKUPIS14R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS14R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS14R :: EN } } # [ doc = "Possible values of the field `WKUPIS15`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WKUPIS15R { # [ doc = "the corresponding wake-up input is disabled, or was inactive at the time the debouncer triggered a wake-up event." ] DIS , # [ doc = "the corresponding wake-up input was active at the time the debouncer triggered a wake-up event." ] EN } impl WKUPIS15R { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { WKUPIS15R :: DIS => false , WKUPIS15R :: EN => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> WKUPIS15R { match value { false => WKUPIS15R :: DIS , true => WKUPIS15R :: EN , } } # [ doc = "Checks if the value of the field is `DIS`" ] # [ inline ] pub fn is_dis ( & self ) -> bool { * self == WKUPIS15R :: DIS } # [ doc = "Checks if the value of the field is `EN`" ] # [ inline ] pub fn is_en ( & self ) -> bool { * self == WKUPIS15R :: EN } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - FWUP Wake-up Status" ] # [ inline ] pub fn fwups ( & self ) -> FWUPSR { FWUPSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - WKUP Wake-up Status" ] # [ inline ] pub fn wkups ( & self ) -> WKUPSR { WKUPSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 2 - Supply Monitor Detection Wake-up Status" ] # [ inline ] pub fn smws ( & self ) -> SMWSR { SMWSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 3 - Brownout Detector Reset Status" ] # [ inline ] pub fn bodrsts ( & self ) -> BODRSTSR { BODRSTSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 4 - Supply Monitor Reset Status" ] # [ inline ] pub fn smrsts ( & self ) -> SMRSTSR { SMRSTSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 5 - Supply Monitor Status" ] # [ inline ] pub fn sms ( & self ) -> SMSR { SMSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 5 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 6 - Supply Monitor Output Status" ] # [ inline ] pub fn smos ( & self ) -> SMOSR { SMOSR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 6 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 7 - 32-kHz Oscillator Selection Status" ] # [ inline ] pub fn oscsel ( & self ) -> OSCSELR { OSCSELR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 12 - FWUP Input Status" ] # [ inline ] pub fn fwupis ( & self ) -> FWUPISR { FWUPISR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 16 - WKUP Input Status 0" ] # [ inline ] pub fn wkupis0 ( & self ) -> WKUPIS0R { WKUPIS0R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 17 - WKUP Input Status 1" ] # [ inline ] pub fn wkupis1 ( & self ) -> WKUPIS1R { WKUPIS1R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 18 - WKUP Input Status 2" ] # [ inline ] pub fn wkupis2 ( & self ) -> WKUPIS2R { WKUPIS2R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 19 - WKUP Input Status 3" ] # [ inline ] pub fn wkupis3 ( & self ) -> WKUPIS3R { WKUPIS3R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 19 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 20 - WKUP Input Status 4" ] # [ inline ] pub fn wkupis4 ( & self ) -> WKUPIS4R { WKUPIS4R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 20 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 21 - WKUP Input Status 5" ] # [ inline ] pub fn wkupis5 ( & self ) -> WKUPIS5R { WKUPIS5R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 22 - WKUP Input Status 6" ] # [ inline ] pub fn wkupis6 ( & self ) -> WKUPIS6R { WKUPIS6R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 23 - WKUP Input Status 7" ] # [ inline ] pub fn wkupis7 ( & self ) -> WKUPIS7R { WKUPIS7R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 24 - WKUP Input Status 8" ] # [ inline ] pub fn wkupis8 ( & self ) -> WKUPIS8R { WKUPIS8R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 25 - WKUP Input Status 9" ] # [ inline ] pub fn wkupis9 ( & self ) -> WKUPIS9R { WKUPIS9R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 25 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 26 - WKUP Input Status 10" ] # [ inline ] pub fn wkupis10 ( & self ) -> WKUPIS10R { WKUPIS10R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 26 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 27 - WKUP Input Status 11" ] # [ inline ] pub fn wkupis11 ( & self ) -> WKUPIS11R { WKUPIS11R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 27 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 28 - WKUP Input Status 12" ] # [ inline ] pub fn wkupis12 ( & self ) -> WKUPIS12R { WKUPIS12R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 29 - WKUP Input Status 13" ] # [ inline ] pub fn wkupis13 ( & self ) -> WKUPIS13R { WKUPIS13R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 30 - WKUP Input Status 14" ] # [ inline ] pub fn wkupis14 ( & self ) -> WKUPIS14R { WKUPIS14R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 30 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 31 - WKUP Input Status 15" ] # [ inline ] pub fn wkupis15 ( & self ) -> WKUPIS15R { WKUPIS15R :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } } } # [ doc = "Real-time Timer" ] pub struct RTT { _marker : PhantomData < * const ( ) > } unsafe impl Send for RTT { } impl RTT { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const rtt :: RegisterBlock { 0x400e_1a30 as * const _ } } impl Deref for RTT { type Target = rtt :: RegisterBlock ; fn deref ( & self ) -> & rtt :: RegisterBlock { unsafe { & * RTT :: ptr ( ) } } } # [ doc = "Real-time Timer" ] pub mod rtt { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Mode Register" ] pub mr : MR , # [ doc = "0x04 - Alarm Register" ] pub ar : AR , # [ doc = "0x08 - Value Register" ] pub vr : VR , # [ doc = "0x0c - Status Register" ] pub sr : SR , } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 RTPRESR { bits : u16 , } impl RTPRESR { # [ 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 ALMIENR { bits : bool , } impl ALMIENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RTTINCIENR { bits : bool , } impl RTTINCIENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RTTRSTR { bits : bool , } impl RTTRSTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _RTPRESW < 'a > { w : & 'a mut W , } impl < 'a > _RTPRESW < '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 } } # [ doc = r" Proxy" ] pub struct _ALMIENW < 'a > { w : & 'a mut W , } impl < 'a > _ALMIENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTTINCIENW < 'a > { w : & 'a mut W , } impl < 'a > _RTTINCIENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _RTTRSTW < 'a > { w : & 'a mut W , } impl < 'a > _RTTRSTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:15 - Real-time Timer Prescaler Value" ] # [ inline ] pub fn rtpres ( & self ) -> RTPRESR { let bits = { const MASK : u16 = 0xffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; RTPRESR { bits } } # [ doc = "Bit 16 - Alarm Interrupt Enable" ] # [ inline ] pub fn almien ( & self ) -> ALMIENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ALMIENR { bits } } # [ doc = "Bit 17 - Real-time Timer Increment Interrupt Enable" ] # [ inline ] pub fn rttincien ( & self ) -> RTTINCIENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 17 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTTINCIENR { bits } } # [ doc = "Bit 18 - Real-time Timer Restart" ] # [ inline ] pub fn rttrst ( & self ) -> RTTRSTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 18 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTTRSTR { 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 = "Bits 0:15 - Real-time Timer Prescaler Value" ] # [ inline ] pub fn rtpres ( & mut self ) -> _RTPRESW { _RTPRESW { w : self } } # [ doc = "Bit 16 - Alarm Interrupt Enable" ] # [ inline ] pub fn almien ( & mut self ) -> _ALMIENW { _ALMIENW { w : self } } # [ doc = "Bit 17 - Real-time Timer Increment Interrupt Enable" ] # [ inline ] pub fn rttincien ( & mut self ) -> _RTTINCIENW { _RTTINCIENW { w : self } } # [ doc = "Bit 18 - Real-time Timer Restart" ] # [ inline ] pub fn rttrst ( & mut self ) -> _RTTRSTW { _RTTRSTW { w : self } } } } # [ doc = "Alarm Register" ] pub struct AR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Alarm Register" ] pub mod ar { # [ 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 :: AR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 ALMVR { bits : u32 , } impl ALMVR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _ALMVW < 'a > { w : & 'a mut W , } impl < 'a > _ALMVW < '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 - Alarm Value" ] # [ inline ] pub fn almv ( & self ) -> ALMVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; ALMVR { 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 - Alarm Value" ] # [ inline ] pub fn almv ( & mut self ) -> _ALMVW { _ALMVW { w : self } } } } # [ doc = "Value Register" ] pub struct VR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Value Register" ] pub mod vr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: VR { # [ 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 CRTVR { bits : u32 , } impl CRTVR { # [ 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 - Current Real-time Value" ] # [ inline ] pub fn crtv ( & self ) -> CRTVR { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; CRTVR { bits } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 ALMSR { bits : bool , } impl ALMSR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct RTTINCR { bits : bool , } impl RTTINCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Real-time Alarm Status" ] # [ inline ] pub fn alms ( & self ) -> ALMSR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ALMSR { bits } } # [ doc = "Bit 1 - Real-time Timer Increment" ] # [ inline ] pub fn rttinc ( & self ) -> RTTINCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; RTTINCR { bits } } } } } # [ doc = "Watchdog Timer" ] pub struct WDT { _marker : PhantomData < * const ( ) > } unsafe impl Send for WDT { } impl WDT { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const wdt :: RegisterBlock { 0x400e_1a50 as * const _ } } impl Deref for WDT { type Target = wdt :: RegisterBlock ; fn deref ( & self ) -> & wdt :: RegisterBlock { unsafe { & * WDT :: ptr ( ) } } } # [ doc = "Watchdog Timer" ] pub mod wdt { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Mode Register" ] pub mr : MR , # [ doc = "0x08 - Status Register" ] pub sr : SR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Control Register" ] pub mod cr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: CR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _WDRSTTW < 'a > { w : & 'a mut W , } impl < 'a > _WDRSTTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `KEY`" ] pub enum KEYW { # [ doc = "Writing any other value in this field aborts the write operation." ] PASSWD } impl KEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { KEYW :: PASSWD => 165 } } } # [ doc = r" Proxy" ] pub struct _KEYW < 'a > { w : & 'a mut W , } impl < 'a > _KEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : KEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( KEYW :: PASSWD ) } # [ 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 } } impl W { # [ doc = "Bit 0 - Watchdog Restart" ] # [ inline ] pub fn wdrstt ( & mut self ) -> _WDRSTTW { _WDRSTTW { w : self } } # [ doc = "Bits 24:31 - Password." ] # [ inline ] pub fn key ( & mut self ) -> _KEYW { _KEYW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WDVR { bits : u16 , } impl WDVR { # [ 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 WDFIENR { bits : bool , } impl WDFIENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WDRSTENR { bits : bool , } impl WDRSTENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WDRPROCR { bits : bool , } impl WDRPROCR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WDDISR { bits : bool , } impl WDDISR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WDDR { bits : u16 , } impl WDDR { # [ 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 WDDBGHLTR { bits : bool , } impl WDDBGHLTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WDIDLEHLTR { bits : bool , } impl WDIDLEHLTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _WDVW < 'a > { w : & 'a mut W , } impl < 'a > _WDVW < '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 _WDFIENW < 'a > { w : & 'a mut W , } impl < 'a > _WDFIENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WDRSTENW < 'a > { w : & 'a mut W , } impl < 'a > _WDRSTENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WDRPROCW < 'a > { w : & 'a mut W , } impl < 'a > _WDRPROCW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WDDISW < 'a > { w : & 'a mut W , } impl < 'a > _WDDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WDDW < 'a > { w : & 'a mut W , } impl < 'a > _WDDW < '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 _WDDBGHLTW < 'a > { w : & 'a mut W , } impl < 'a > _WDDBGHLTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _WDIDLEHLTW < 'a > { w : & 'a mut W , } impl < 'a > _WDIDLEHLTW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 } } 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 Value" ] # [ inline ] pub fn wdv ( & self ) -> WDVR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WDVR { bits } } # [ doc = "Bit 12 - Watchdog Fault Interrupt Enable" ] # [ inline ] pub fn wdfien ( & self ) -> WDFIENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 12 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDFIENR { bits } } # [ doc = "Bit 13 - Watchdog Reset Enable" ] # [ inline ] pub fn wdrsten ( & self ) -> WDRSTENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 13 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDRSTENR { bits } } # [ doc = "Bit 14 - Watchdog Reset Processor" ] # [ inline ] pub fn wdrproc ( & self ) -> WDRPROCR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 14 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDRPROCR { bits } } # [ doc = "Bit 15 - Watchdog Disable" ] # [ inline ] pub fn wddis ( & self ) -> WDDISR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDDISR { bits } } # [ doc = "Bits 16:27 - Watchdog Delta Value" ] # [ inline ] pub fn wdd ( & self ) -> WDDR { let bits = { const MASK : u16 = 0x0fff ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u16 } ; WDDR { bits } } # [ doc = "Bit 28 - Watchdog Debug Halt" ] # [ inline ] pub fn wddbghlt ( & self ) -> WDDBGHLTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 28 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDDBGHLTR { bits } } # [ doc = "Bit 29 - Watchdog Idle Halt" ] # [ inline ] pub fn wdidlehlt ( & self ) -> WDIDLEHLTR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 29 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDIDLEHLTR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x3fff_2fff } } # [ 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 Value" ] # [ inline ] pub fn wdv ( & mut self ) -> _WDVW { _WDVW { w : self } } # [ doc = "Bit 12 - Watchdog Fault Interrupt Enable" ] # [ inline ] pub fn wdfien ( & mut self ) -> _WDFIENW { _WDFIENW { w : self } } # [ doc = "Bit 13 - Watchdog Reset Enable" ] # [ inline ] pub fn wdrsten ( & mut self ) -> _WDRSTENW { _WDRSTENW { w : self } } # [ doc = "Bit 14 - Watchdog Reset Processor" ] # [ inline ] pub fn wdrproc ( & mut self ) -> _WDRPROCW { _WDRPROCW { w : self } } # [ doc = "Bit 15 - Watchdog Disable" ] # [ inline ] pub fn wddis ( & mut self ) -> _WDDISW { _WDDISW { w : self } } # [ doc = "Bits 16:27 - Watchdog Delta Value" ] # [ inline ] pub fn wdd ( & mut self ) -> _WDDW { _WDDW { w : self } } # [ doc = "Bit 28 - Watchdog Debug Halt" ] # [ inline ] pub fn wddbghlt ( & mut self ) -> _WDDBGHLTW { _WDDBGHLTW { w : self } } # [ doc = "Bit 29 - Watchdog Idle Halt" ] # [ inline ] pub fn wdidlehlt ( & mut self ) -> _WDIDLEHLTW { _WDIDLEHLTW { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 WDUNFR { bits : bool , } impl WDUNFR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct WDERRR { bits : bool , } impl WDERRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 Underflow" ] # [ inline ] pub fn wdunf ( & self ) -> WDUNFR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDUNFR { bits } } # [ doc = "Bit 1 - Watchdog Error" ] # [ inline ] pub fn wderr ( & self ) -> WDERRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WDERRR { bits } } } } } # [ 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 { 0x400e_1a60 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 - Control Register" ] pub cr : CR , # [ doc = "0x04 - Mode Register" ] pub mr : MR , # [ doc = "0x08 - Time Register" ] pub timr : TIMR , # [ doc = "0x0c - Calendar Register" ] pub calr : CALR , # [ doc = "0x10 - Time Alarm Register" ] pub timalr : TIMALR , # [ doc = "0x14 - Calendar Alarm Register" ] pub calalr : CALALR , # [ doc = "0x18 - Status Register" ] pub sr : SR , # [ doc = "0x1c - Status Clear Command Register" ] pub sccr : SCCR , # [ doc = "0x20 - Interrupt Enable Register" ] pub ier : IER , # [ doc = "0x24 - Interrupt Disable Register" ] pub idr : IDR , # [ doc = "0x28 - Interrupt Mask Register" ] pub imr : IMR , # [ doc = "0x2c - Valid Entry Register" ] pub ver : VER , _reserved12 : [ u8 ; 180usize ] , # [ doc = "0xe4 - Write Protect Mode Register" ] pub wpmr : WPMR , } # [ doc = "Control Register" ] pub struct CR { register : :: vcell :: VolatileCell < u32 > } # [ 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 < F > ( & 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 < F > ( & 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 UPDTIMR { bits : bool , } impl UPDTIMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct UPDCALR { bits : bool , } impl UPDCALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `TIMEVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TIMEVSELR { # [ doc = "Minute change" ] MINUTE , # [ doc = "Hour change" ] HOUR , # [ doc = "Every day at midnight" ] MIDNIGHT , # [ doc = "Every day at noon" ] NOON } impl TIMEVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { TIMEVSELR :: MINUTE => 0 , TIMEVSELR :: HOUR => 0x01 , TIMEVSELR :: MIDNIGHT => 0x02 , TIMEVSELR :: NOON => 0x03 } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> TIMEVSELR { match value { 0 => TIMEVSELR :: MINUTE , 1 => TIMEVSELR :: HOUR , 2 => TIMEVSELR :: MIDNIGHT , 3 => TIMEVSELR :: NOON , _ => unreachable ! ( ) , } } # [ doc = "Checks if the value of the field is `MINUTE`" ] # [ inline ] pub fn is_minute ( & self ) -> bool { * self == TIMEVSELR :: MINUTE } # [ doc = "Checks if the value of the field is `HOUR`" ] # [ inline ] pub fn is_hour ( & self ) -> bool { * self == TIMEVSELR :: HOUR } # [ doc = "Checks if the value of the field is `MIDNIGHT`" ] # [ inline ] pub fn is_midnight ( & self ) -> bool { * self == TIMEVSELR :: MIDNIGHT } # [ doc = "Checks if the value of the field is `NOON`" ] # [ inline ] pub fn is_noon ( & self ) -> bool { * self == TIMEVSELR :: NOON } } # [ doc = "Possible values of the field `CALEVSEL`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CALEVSELR { # [ doc = "Week change (every Monday at time 00:00:00)" ] WEEK , # [ doc = "Month change (every 01 of each month at time 00:00:00)" ] MONTH , # [ doc = "Year change (every January 1 at time 00:00:00)" ] YEAR , # [ doc = r" Reserved" ] _Reserved ( u8 ) } impl CALEVSELR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { match * self { CALEVSELR :: WEEK => 0 , CALEVSELR :: MONTH => 0x01 , CALEVSELR :: YEAR => 0x02 , CALEVSELR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u8 ) -> CALEVSELR { match value { 0 => CALEVSELR :: WEEK , 1 => CALEVSELR :: MONTH , 2 => CALEVSELR :: YEAR , i => CALEVSELR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `WEEK`" ] # [ inline ] pub fn is_week ( & self ) -> bool { * self == CALEVSELR :: WEEK } # [ doc = "Checks if the value of the field is `MONTH`" ] # [ inline ] pub fn is_month ( & self ) -> bool { * self == CALEVSELR :: MONTH } # [ doc = "Checks if the value of the field is `YEAR`" ] # [ inline ] pub fn is_year ( & self ) -> bool { * self == CALEVSELR :: YEAR } } # [ doc = r" Proxy" ] pub struct _UPDTIMW < 'a > { w : & 'a mut W , } impl < 'a > _UPDTIMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _UPDCALW < 'a > { w : & 'a mut W , } impl < 'a > _UPDCALW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `TIMEVSEL`" ] pub enum TIMEVSELW { # [ doc = "Minute change" ] MINUTE , # [ doc = "Hour change" ] HOUR , # [ doc = "Every day at midnight" ] MIDNIGHT , # [ doc = "Every day at noon" ] NOON } impl TIMEVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { TIMEVSELW :: MINUTE => 0 , TIMEVSELW :: HOUR => 1 , TIMEVSELW :: MIDNIGHT => 2 , TIMEVSELW :: NOON => 3 } } } # [ doc = r" Proxy" ] pub struct _TIMEVSELW < 'a > { w : & 'a mut W , } impl < 'a > _TIMEVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : TIMEVSELW ) -> & 'a mut W { { self . bits ( variant . _bits ( ) ) } } # [ doc = "Minute change" ] # [ inline ] pub fn minute ( self ) -> & 'a mut W { self . variant ( TIMEVSELW :: MINUTE ) } # [ doc = "Hour change" ] # [ inline ] pub fn hour ( self ) -> & 'a mut W { self . variant ( TIMEVSELW :: HOUR ) } # [ doc = "Every day at midnight" ] # [ inline ] pub fn midnight ( self ) -> & 'a mut W { self . variant ( TIMEVSELW :: MIDNIGHT ) } # [ doc = "Every day at noon" ] # [ inline ] pub fn noon ( self ) -> & 'a mut W { self . variant ( TIMEVSELW :: NOON ) } # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub 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 = "Values that can be written to the field `CALEVSEL`" ] pub enum CALEVSELW { # [ doc = "Week change (every Monday at time 00:00:00)" ] WEEK , # [ doc = "Month change (every 01 of each month at time 00:00:00)" ] MONTH , # [ doc = "Year change (every January 1 at time 00:00:00)" ] YEAR } impl CALEVSELW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u8 { match * self { CALEVSELW :: WEEK => 0 , CALEVSELW :: MONTH => 1 , CALEVSELW :: YEAR => 2 } } } # [ doc = r" Proxy" ] pub struct _CALEVSELW < 'a > { w : & 'a mut W , } impl < 'a > _CALEVSELW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : CALEVSELW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Week change (every Monday at time 00:00:00)" ] # [ inline ] pub fn week ( self ) -> & 'a mut W { self . variant ( CALEVSELW :: WEEK ) } # [ doc = "Month change (every 01 of each month at time 00:00:00)" ] # [ inline ] pub fn month ( self ) -> & 'a mut W { self . variant ( CALEVSELW :: MONTH ) } # [ doc = "Year change (every January 1 at time 00:00:00)" ] # [ inline ] pub fn year ( self ) -> & 'a mut W { self . variant ( CALEVSELW :: YEAR ) } # [ 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 = "Bit 0 - Update Request Time Register" ] # [ inline ] pub fn updtim ( & self ) -> UPDTIMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UPDTIMR { bits } } # [ doc = "Bit 1 - Update Request Calendar Register" ] # [ inline ] pub fn updcal ( & self ) -> UPDCALR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; UPDCALR { bits } } # [ doc = "Bits 8:9 - Time Event Selection" ] # [ inline ] pub fn timevsel ( & self ) -> TIMEVSELR { TIMEVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } # [ doc = "Bits 16:17 - Calendar Event Selection" ] # [ inline ] pub fn calevsel ( & self ) -> CALEVSELR { CALEVSELR :: _from ( { const MASK : u8 = 0x03 ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ) } } 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 Request Time Register" ] # [ inline ] pub fn updtim ( & mut self ) -> _UPDTIMW { _UPDTIMW { w : self } } # [ doc = "Bit 1 - Update Request Calendar Register" ] # [ inline ] pub fn updcal ( & mut self ) -> _UPDCALW { _UPDCALW { w : self } } # [ doc = "Bits 8:9 - Time Event Selection" ] # [ inline ] pub fn timevsel ( & mut self ) -> _TIMEVSELW { _TIMEVSELW { w : self } } # [ doc = "Bits 16:17 - Calendar Event Selection" ] # [ inline ] pub fn calevsel ( & mut self ) -> _CALEVSELW { _CALEVSELW { w : self } } } } # [ doc = "Mode Register" ] pub struct MR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Mode Register" ] pub mod mr { # [ 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 :: MR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 HRMODR { bits : bool , } impl HRMODR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _HRMODW < 'a > { w : & 'a mut W , } impl < 'a > _HRMODW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 - 12-/24-hour Mode" ] # [ inline ] pub fn hrmod ( & self ) -> HRMODR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HRMODR { 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 - 12-/24-hour Mode" ] # [ inline ] pub fn hrmod ( & mut self ) -> _HRMODW { _HRMODW { w : self } } } } # [ doc = "Time Register" ] pub struct TIMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Time Register" ] pub mod timr { # [ 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 :: TIMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SECR { bits : u8 , } impl SECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MINR { bits : u8 , } impl MINR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct HOURR { bits : u8 , } impl HOURR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct AMPMR { bits : bool , } impl AMPMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SECW < 'a > { w : & 'a mut W , } impl < 'a > _SECW < '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 } } # [ doc = r" Proxy" ] pub struct _MINW < 'a > { w : & 'a mut W , } impl < 'a > _MINW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _HOURW < 'a > { w : & 'a mut W , } impl < 'a > _HOURW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _AMPMW < 'a > { w : & 'a mut W , } impl < 'a > _AMPMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:6 - Current Second" ] # [ inline ] pub fn sec ( & self ) -> SECR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SECR { bits } } # [ doc = "Bits 8:14 - Current Minute" ] # [ inline ] pub fn min ( & self ) -> MINR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MINR { bits } } # [ doc = "Bits 16:21 - Current Hour" ] # [ inline ] pub fn hour ( & self ) -> HOURR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HOURR { bits } } # [ doc = "Bit 22 - Ante Meridiem Post Meridiem Indicator" ] # [ inline ] pub fn ampm ( & self ) -> AMPMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AMPMR { 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:6 - Current Second" ] # [ inline ] pub fn sec ( & mut self ) -> _SECW { _SECW { w : self } } # [ doc = "Bits 8:14 - Current Minute" ] # [ inline ] pub fn min ( & mut self ) -> _MINW { _MINW { w : self } } # [ doc = "Bits 16:21 - Current Hour" ] # [ inline ] pub fn hour ( & mut self ) -> _HOURW { _HOURW { w : self } } # [ doc = "Bit 22 - Ante Meridiem Post Meridiem Indicator" ] # [ inline ] pub fn ampm ( & mut self ) -> _AMPMW { _AMPMW { w : self } } } } # [ doc = "Calendar Register" ] pub struct CALR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Calendar 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 < F > ( & 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 < F > ( & 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 CENTR { bits : u8 , } impl CENTR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct YEARR { bits : u8 , } impl YEARR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MONTHR { bits : u8 , } impl MONTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DAYR { bits : u8 , } impl DAYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DATER { bits : u8 , } impl DATER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Proxy" ] pub struct _CENTW < 'a > { w : & 'a mut W , } impl < 'a > _CENTW < '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 } } # [ doc = r" Proxy" ] pub struct _YEARW < 'a > { w : & 'a mut W , } impl < 'a > _YEARW < '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 _MONTHW < 'a > { w : & 'a mut W , } impl < 'a > _MONTHW < '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 _DAYW < 'a > { w : & 'a mut W , } impl < 'a > _DAYW < '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 = 21 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _DATEW < 'a > { w : & 'a mut W , } impl < 'a > _DATEW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 = "Bits 0:6 - Current Century" ] # [ inline ] pub fn cent ( & self ) -> CENTR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; CENTR { bits } } # [ doc = "Bits 8:15 - Current Year" ] # [ inline ] pub fn year ( & self ) -> YEARR { let bits = { const MASK : u8 = 0xff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; YEARR { bits } } # [ doc = "Bits 16:20 - Current Month" ] # [ inline ] pub fn month ( & self ) -> MONTHR { let bits = { const MASK : u8 = 0x1f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MONTHR { bits } } # [ doc = "Bits 21:23 - Current Day in Current Week" ] # [ inline ] pub fn day ( & self ) -> DAYR { let bits = { const MASK : u8 = 0x07 ; const OFFSET : u8 = 21 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DAYR { bits } } # [ doc = "Bits 24:29 - Current Day in Current Month" ] # [ inline ] pub fn date ( & self ) -> DATER { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DATER { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0121_0720 } } # [ 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:6 - Current Century" ] # [ inline ] pub fn cent ( & mut self ) -> _CENTW { _CENTW { w : self } } # [ doc = "Bits 8:15 - Current Year" ] # [ inline ] pub fn year ( & mut self ) -> _YEARW { _YEARW { w : self } } # [ doc = "Bits 16:20 - Current Month" ] # [ inline ] pub fn month ( & mut self ) -> _MONTHW { _MONTHW { w : self } } # [ doc = "Bits 21:23 - Current Day in Current Week" ] # [ inline ] pub fn day ( & mut self ) -> _DAYW { _DAYW { w : self } } # [ doc = "Bits 24:29 - Current Day in Current Month" ] # [ inline ] pub fn date ( & mut self ) -> _DATEW { _DATEW { w : self } } } } # [ doc = "Time Alarm Register" ] pub struct TIMALR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Time Alarm Register" ] pub mod timalr { # [ 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 :: TIMALR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 SECR { bits : u8 , } impl SECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct SECENR { bits : bool , } impl SECENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct MINR { bits : u8 , } impl MINR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MINENR { bits : bool , } impl MINENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HOURR { bits : u8 , } impl HOURR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct AMPMR { bits : bool , } impl AMPMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct HOURENR { bits : bool , } impl HOURENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _SECW < 'a > { w : & 'a mut W , } impl < 'a > _SECW < '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 } } # [ doc = r" Proxy" ] pub struct _SECENW < 'a > { w : & 'a mut W , } impl < 'a > _SECENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _MINW < 'a > { w : & 'a mut W , } impl < 'a > _MINW < '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 = 8 ; self . w . bits &= ! ( ( MASK as u32 ) << OFFSET ) ; self . w . bits |= ( ( value & MASK ) as u32 ) << OFFSET ; self . w } } # [ doc = r" Proxy" ] pub struct _MINENW < 'a > { w : & 'a mut W , } impl < 'a > _MINENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HOURW < 'a > { w : & 'a mut W , } impl < 'a > _HOURW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _AMPMW < 'a > { w : & 'a mut W , } impl < 'a > _AMPMW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _HOURENW < 'a > { w : & 'a mut W , } impl < 'a > _HOURENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Bits 0:6 - Second Alarm" ] # [ inline ] pub fn sec ( & self ) -> SECR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; SECR { bits } } # [ doc = "Bit 7 - Second Alarm Enable" ] # [ inline ] pub fn secen ( & self ) -> SECENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 7 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SECENR { bits } } # [ doc = "Bits 8:14 - Minute Alarm" ] # [ inline ] pub fn min ( & self ) -> MINR { let bits = { const MASK : u8 = 0x7f ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MINR { bits } } # [ doc = "Bit 15 - Minute Alarm Enable" ] # [ inline ] pub fn minen ( & self ) -> MINENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 15 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MINENR { bits } } # [ doc = "Bits 16:21 - Hour Alarm" ] # [ inline ] pub fn hour ( & self ) -> HOURR { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; HOURR { bits } } # [ doc = "Bit 22 - AM/PM Indicator" ] # [ inline ] pub fn ampm ( & self ) -> AMPMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 22 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; AMPMR { bits } } # [ doc = "Bit 23 - Hour Alarm Enable" ] # [ inline ] pub fn houren ( & self ) -> HOURENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; HOURENR { 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:6 - Second Alarm" ] # [ inline ] pub fn sec ( & mut self ) -> _SECW { _SECW { w : self } } # [ doc = "Bit 7 - Second Alarm Enable" ] # [ inline ] pub fn secen ( & mut self ) -> _SECENW { _SECENW { w : self } } # [ doc = "Bits 8:14 - Minute Alarm" ] # [ inline ] pub fn min ( & mut self ) -> _MINW { _MINW { w : self } } # [ doc = "Bit 15 - Minute Alarm Enable" ] # [ inline ] pub fn minen ( & mut self ) -> _MINENW { _MINENW { w : self } } # [ doc = "Bits 16:21 - Hour Alarm" ] # [ inline ] pub fn hour ( & mut self ) -> _HOURW { _HOURW { w : self } } # [ doc = "Bit 22 - AM/PM Indicator" ] # [ inline ] pub fn ampm ( & mut self ) -> _AMPMW { _AMPMW { w : self } } # [ doc = "Bit 23 - Hour Alarm Enable" ] # [ inline ] pub fn houren ( & mut self ) -> _HOURENW { _HOURENW { w : self } } } } # [ doc = "Calendar Alarm Register" ] pub struct CALALR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Calendar Alarm Register" ] pub mod calalr { # [ 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 :: CALALR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 MONTHR { bits : u8 , } impl MONTHR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct MTHENR { bits : bool , } impl MTHENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct DATER { bits : u8 , } impl DATER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u8 { self . bits } } # [ doc = r" Value of the field" ] pub struct DATEENR { bits : bool , } impl DATEENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! 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 _MONTHW < 'a > { w : & 'a mut W , } impl < 'a > _MONTHW < '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 _MTHENW < 'a > { w : & 'a mut W , } impl < 'a > _MTHENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _DATEW < 'a > { w : & 'a mut W , } impl < 'a > _DATEW < 'a > { # [ doc = r" Writes raw bits to the field" ] # [ inline ] pub unsafe fn bits ( self , value : u8 ) -> & 'a mut W { const MASK : u8 = 0x3f ; 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 _DATEENW < 'a > { w : & 'a mut W , } impl < 'a > _DATEENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 16:20 - Month Alarm" ] # [ inline ] pub fn month ( & self ) -> MONTHR { let bits = { const MASK : u8 = 0x1f ; const OFFSET : u8 = 16 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; MONTHR { bits } } # [ doc = "Bit 23 - Month Alarm Enable" ] # [ inline ] pub fn mthen ( & self ) -> MTHENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 23 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; MTHENR { bits } } # [ doc = "Bits 24:29 - Date Alarm" ] # [ inline ] pub fn date ( & self ) -> DATER { let bits = { const MASK : u8 = 0x3f ; const OFFSET : u8 = 24 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u8 } ; DATER { bits } } # [ doc = "Bit 31 - Date Alarm Enable" ] # [ inline ] pub fn dateen ( & self ) -> DATEENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 31 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; DATEENR { bits } } } impl W { # [ doc = r" Reset value of the register" ] # [ inline ] pub fn reset_value ( ) -> W { W { bits : 0x0101_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 16:20 - Month Alarm" ] # [ inline ] pub fn month ( & mut self ) -> _MONTHW { _MONTHW { w : self } } # [ doc = "Bit 23 - Month Alarm Enable" ] # [ inline ] pub fn mthen ( & mut self ) -> _MTHENW { _MTHENW { w : self } } # [ doc = "Bits 24:29 - Date Alarm" ] # [ inline ] pub fn date ( & mut self ) -> _DATEW { _DATEW { w : self } } # [ doc = "Bit 31 - Date Alarm Enable" ] # [ inline ] pub fn dateen ( & mut self ) -> _DATEENW { _DATEENW { w : self } } } } # [ doc = "Status Register" ] pub struct SR { register : :: vcell :: VolatileCell < u32 > } # [ 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 = "Possible values of the field `ACKUPD`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ACKUPDR { # [ doc = "Time and calendar registers cannot be updated." ] FREERUN , # [ doc = "Time and calendar registers can be updated." ] UPDATE } impl ACKUPDR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { ACKUPDR :: FREERUN => false , ACKUPDR :: UPDATE => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> ACKUPDR { match value { false => ACKUPDR :: FREERUN , true => ACKUPDR :: UPDATE , } } # [ doc = "Checks if the value of the field is `FREERUN`" ] # [ inline ] pub fn is_freerun ( & self ) -> bool { * self == ACKUPDR :: FREERUN } # [ doc = "Checks if the value of the field is `UPDATE`" ] # [ inline ] pub fn is_update ( & self ) -> bool { * self == ACKUPDR :: UPDATE } } # [ doc = "Possible values of the field `ALARM`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum ALARMR { # [ doc = "No alarm matching condition occurred." ] NO_ALARMEVENT , # [ doc = "An alarm matching condition has occurred." ] ALARMEVENT } impl ALARMR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { ALARMR :: NO_ALARMEVENT => false , ALARMR :: ALARMEVENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> ALARMR { match value { false => ALARMR :: NO_ALARMEVENT , true => ALARMR :: ALARMEVENT , } } # [ doc = "Checks if the value of the field is `NO_ALARMEVENT`" ] # [ inline ] pub fn is_no_alarmevent ( & self ) -> bool { * self == ALARMR :: NO_ALARMEVENT } # [ doc = "Checks if the value of the field is `ALARMEVENT`" ] # [ inline ] pub fn is_alarmevent ( & self ) -> bool { * self == ALARMR :: ALARMEVENT } } # [ doc = "Possible values of the field `SEC`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum SECR { # [ doc = "No second event has occurred since the last clear." ] NO_SECEVENT , # [ doc = "At least one second event has occurred since the last clear." ] SECEVENT } impl SECR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { SECR :: NO_SECEVENT => false , SECR :: SECEVENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> SECR { match value { false => SECR :: NO_SECEVENT , true => SECR :: SECEVENT , } } # [ doc = "Checks if the value of the field is `NO_SECEVENT`" ] # [ inline ] pub fn is_no_secevent ( & self ) -> bool { * self == SECR :: NO_SECEVENT } # [ doc = "Checks if the value of the field is `SECEVENT`" ] # [ inline ] pub fn is_secevent ( & self ) -> bool { * self == SECR :: SECEVENT } } # [ doc = "Possible values of the field `TIMEV`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum TIMEVR { # [ doc = "No time event has occurred since the last clear." ] NO_TIMEVENT , # [ doc = "At least one time event has occurred since the last clear." ] TIMEVENT } impl TIMEVR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { TIMEVR :: NO_TIMEVENT => false , TIMEVR :: TIMEVENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> TIMEVR { match value { false => TIMEVR :: NO_TIMEVENT , true => TIMEVR :: TIMEVENT , } } # [ doc = "Checks if the value of the field is `NO_TIMEVENT`" ] # [ inline ] pub fn is_no_timevent ( & self ) -> bool { * self == TIMEVR :: NO_TIMEVENT } # [ doc = "Checks if the value of the field is `TIMEVENT`" ] # [ inline ] pub fn is_timevent ( & self ) -> bool { * self == TIMEVR :: TIMEVENT } } # [ doc = "Possible values of the field `CALEV`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum CALEVR { # [ doc = "No calendar event has occurred since the last clear." ] NO_CALEVENT , # [ doc = "At least one calendar event has occurred since the last clear." ] CALEVENT } impl CALEVR { # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { match * self { CALEVR :: NO_CALEVENT => false , CALEVR :: CALEVENT => true } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : bool ) -> CALEVR { match value { false => CALEVR :: NO_CALEVENT , true => CALEVR :: CALEVENT , } } # [ doc = "Checks if the value of the field is `NO_CALEVENT`" ] # [ inline ] pub fn is_no_calevent ( & self ) -> bool { * self == CALEVR :: NO_CALEVENT } # [ doc = "Checks if the value of the field is `CALEVENT`" ] # [ inline ] pub fn is_calevent ( & self ) -> bool { * self == CALEVR :: CALEVENT } } impl R { # [ doc = r" Value of the register as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } # [ doc = "Bit 0 - Acknowledge for Update" ] # [ inline ] pub fn ackupd ( & self ) -> ACKUPDR { ACKUPDR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 1 - Alarm Flag" ] # [ inline ] pub fn alarm ( & self ) -> ALARMR { ALARMR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 2 - Second Event" ] # [ inline ] pub fn sec ( & self ) -> SECR { SECR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 3 - Time Event" ] # [ inline ] pub fn timev ( & self ) -> TIMEVR { TIMEVR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } # [ doc = "Bit 4 - Calendar Event" ] # [ inline ] pub fn calev ( & self ) -> CALEVR { CALEVR :: _from ( { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ) } } } # [ doc = "Status Clear Command Register" ] pub struct SCCR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Status Clear Command Register" ] pub mod sccr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: SCCR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _ACKCLRW < 'a > { w : & 'a mut W , } impl < 'a > _ACKCLRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ALRCLRW < 'a > { w : & 'a mut W , } impl < 'a > _ALRCLRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SECCLRW < 'a > { w : & 'a mut W , } impl < 'a > _SECCLRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMCLRW < 'a > { w : & 'a mut W , } impl < 'a > _TIMCLRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CALCLRW < 'a > { w : & 'a mut W , } impl < 'a > _CALCLRW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Acknowledge Clear" ] # [ inline ] pub fn ackclr ( & mut self ) -> _ACKCLRW { _ACKCLRW { w : self } } # [ doc = "Bit 1 - Alarm Clear" ] # [ inline ] pub fn alrclr ( & mut self ) -> _ALRCLRW { _ALRCLRW { w : self } } # [ doc = "Bit 2 - Second Clear" ] # [ inline ] pub fn secclr ( & mut self ) -> _SECCLRW { _SECCLRW { w : self } } # [ doc = "Bit 3 - Time Clear" ] # [ inline ] pub fn timclr ( & mut self ) -> _TIMCLRW { _TIMCLRW { w : self } } # [ doc = "Bit 4 - Calendar Clear" ] # [ inline ] pub fn calclr ( & mut self ) -> _CALCLRW { _CALCLRW { w : self } } } } # [ doc = "Interrupt Enable Register" ] pub struct IER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Enable Register" ] pub mod ier { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IER { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _ACKENW < 'a > { w : & 'a mut W , } impl < 'a > _ACKENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ALRENW < 'a > { w : & 'a mut W , } impl < 'a > _ALRENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SECENW < 'a > { w : & 'a mut W , } impl < 'a > _SECENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMENW < 'a > { w : & 'a mut W , } impl < 'a > _TIMENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CALENW < 'a > { w : & 'a mut W , } impl < 'a > _CALENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Acknowledge Update Interrupt Enable" ] # [ inline ] pub fn acken ( & mut self ) -> _ACKENW { _ACKENW { w : self } } # [ doc = "Bit 1 - Alarm Interrupt Enable" ] # [ inline ] pub fn alren ( & mut self ) -> _ALRENW { _ALRENW { w : self } } # [ doc = "Bit 2 - Second Event Interrupt Enable" ] # [ inline ] pub fn secen ( & mut self ) -> _SECENW { _SECENW { w : self } } # [ doc = "Bit 3 - Time Event Interrupt Enable" ] # [ inline ] pub fn timen ( & mut self ) -> _TIMENW { _TIMENW { w : self } } # [ doc = "Bit 4 - Calendar Event Interrupt Enable" ] # [ inline ] pub fn calen ( & mut self ) -> _CALENW { _CALENW { w : self } } } } # [ doc = "Interrupt Disable Register" ] pub struct IDR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Disable Register" ] pub mod idr { # [ doc = r" Value to write to the register" ] pub struct W { bits : u32 , } impl super :: IDR { # [ doc = r" Writes to the register" ] # [ inline ] pub fn write < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; f ( & mut w ) ; self . register . set ( w . bits ) ; } } # [ doc = r" Proxy" ] pub struct _ACKDISW < 'a > { w : & 'a mut W , } impl < 'a > _ACKDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _ALRDISW < 'a > { w : & 'a mut W , } impl < 'a > _ALRDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _SECDISW < 'a > { w : & 'a mut W , } impl < 'a > _SECDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _TIMDISW < 'a > { w : & 'a mut W , } impl < 'a > _TIMDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 _CALDISW < 'a > { w : & 'a mut W , } impl < 'a > _CALDISW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 W { # [ doc = "Bit 0 - Acknowledge Update Interrupt Disable" ] # [ inline ] pub fn ackdis ( & mut self ) -> _ACKDISW { _ACKDISW { w : self } } # [ doc = "Bit 1 - Alarm Interrupt Disable" ] # [ inline ] pub fn alrdis ( & mut self ) -> _ALRDISW { _ALRDISW { w : self } } # [ doc = "Bit 2 - Second Event Interrupt Disable" ] # [ inline ] pub fn secdis ( & mut self ) -> _SECDISW { _SECDISW { w : self } } # [ doc = "Bit 3 - Time Event Interrupt Disable" ] # [ inline ] pub fn timdis ( & mut self ) -> _TIMDISW { _TIMDISW { w : self } } # [ doc = "Bit 4 - Calendar Event Interrupt Disable" ] # [ inline ] pub fn caldis ( & mut self ) -> _CALDISW { _CALDISW { w : self } } } } # [ doc = "Interrupt Mask Register" ] pub struct IMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Interrupt Mask Register" ] pub mod imr { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: IMR { # [ 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 ACKR { bits : bool , } impl ACKR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct ALRR { bits : bool , } impl ALRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct SECR { bits : bool , } impl SECR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct TIMR { bits : bool , } impl TIMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct CALR { bits : bool , } impl CALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Acknowledge Update Interrupt Mask" ] # [ inline ] pub fn ack ( & self ) -> ACKR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ACKR { bits } } # [ doc = "Bit 1 - Alarm Interrupt Mask" ] # [ inline ] pub fn alr ( & self ) -> ALRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; ALRR { bits } } # [ doc = "Bit 2 - Second Event Interrupt Mask" ] # [ inline ] pub fn sec ( & self ) -> SECR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; SECR { bits } } # [ doc = "Bit 3 - Time Event Interrupt Mask" ] # [ inline ] pub fn tim ( & self ) -> TIMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; TIMR { bits } } # [ doc = "Bit 4 - Calendar Event Interrupt Mask" ] # [ inline ] pub fn cal ( & self ) -> CALR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 4 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; CALR { bits } } } } # [ doc = "Valid Entry Register" ] pub struct VER { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Valid Entry Register" ] pub mod ver { # [ doc = r" Value read from the register" ] pub struct R { bits : u32 , } impl super :: VER { # [ 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 NVTIMR { bits : bool , } impl NVTIMR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NVCALR { bits : bool , } impl NVCALR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NVTIMALRR { bits : bool , } impl NVTIMALRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = r" Value of the field" ] pub struct NVCALALRR { bits : bool , } impl NVCALALRR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & 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 - Non-valid Time" ] # [ inline ] pub fn nvtim ( & self ) -> NVTIMR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NVTIMR { bits } } # [ doc = "Bit 1 - Non-valid Calendar" ] # [ inline ] pub fn nvcal ( & self ) -> NVCALR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 1 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NVCALR { bits } } # [ doc = "Bit 2 - Non-valid Time Alarm" ] # [ inline ] pub fn nvtimalr ( & self ) -> NVTIMALRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 2 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NVTIMALRR { bits } } # [ doc = "Bit 3 - Non-valid Calendar Alarm" ] # [ inline ] pub fn nvcalalr ( & self ) -> NVCALALRR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 3 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; NVCALALRR { bits } } } } # [ doc = "Write Protect Mode Register" ] pub struct WPMR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "Write Protect Mode Register" ] pub mod wpmr { # [ 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 :: WPMR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & 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 WPENR { bits : bool , } impl WPENR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bit ( & self ) -> bool { self . bits } # [ doc = r" Returns `true` if the bit is clear (0)" ] # [ inline ] pub fn bit_is_clear ( & self ) -> bool { ! self . bit ( ) } # [ doc = r" Returns `true` if the bit is set (1)" ] # [ inline ] pub fn bit_is_set ( & self ) -> bool { self . bit ( ) } } # [ doc = "Possible values of the field `WPKEY`" ] # [ derive ( Clone , Copy , Debug , PartialEq ) ] pub enum WPKEYR { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD , # [ doc = r" Reserved" ] _Reserved ( u32 ) } impl WPKEYR { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { match * self { WPKEYR :: PASSWD => 0x0052_5443 , WPKEYR :: _Reserved ( bits ) => bits } } # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _from ( value : u32 ) -> WPKEYR { match value { 5395523 => WPKEYR :: PASSWD , i => WPKEYR :: _Reserved ( i ) , } } # [ doc = "Checks if the value of the field is `PASSWD`" ] # [ inline ] pub fn is_passwd ( & self ) -> bool { * self == WPKEYR :: PASSWD } } # [ doc = r" Proxy" ] pub struct _WPENW < 'a > { w : & 'a mut W , } impl < 'a > _WPENW < 'a > { # [ doc = r" Sets the field bit" ] pub fn set_bit ( self ) -> & 'a mut W { self . bit ( true ) } # [ doc = r" Clears the field bit" ] pub fn clear_bit ( self ) -> & 'a mut W { self . bit ( false ) } # [ doc = 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 = "Values that can be written to the field `WPKEY`" ] pub enum WPKEYW { # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] PASSWD } impl WPKEYW { # [ allow ( missing_docs ) ] # [ doc ( hidden ) ] # [ inline ] pub fn _bits ( & self ) -> u32 { match * self { WPKEYW :: PASSWD => 5395523 } } } # [ doc = r" Proxy" ] pub struct _WPKEYW < 'a > { w : & 'a mut W , } impl < 'a > _WPKEYW < 'a > { # [ doc = r" Writes `variant` to the field" ] # [ inline ] pub fn variant ( self , variant : WPKEYW ) -> & 'a mut W { unsafe { self . bits ( variant . _bits ( ) ) } } # [ doc = "Writing any other value in this field aborts the write operation of the WPEN bit.Always reads as 0." ] # [ inline ] pub fn passwd ( self ) -> & 'a mut W { self . variant ( WPKEYW :: PASSWD ) } # [ 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 = 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 0 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & self ) -> WPENR { let bits = { const MASK : bool = true ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) != 0 } ; WPENR { bits } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & self ) -> WPKEYR { WPKEYR :: _from ( { const MASK : u32 = 0x00ff_ffff ; const OFFSET : u8 = 8 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ) } } 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 - Write Protect Enable" ] # [ inline ] pub fn wpen ( & mut self ) -> _WPENW { _WPENW { w : self } } # [ doc = "Bits 8:31 - Write Protect KEY" ] # [ inline ] pub fn wpkey ( & mut self ) -> _WPKEYW { _WPKEYW { w : self } } } } } # [ doc = "General Purpose Backup Registers" ] pub struct GPBR { _marker : PhantomData < * const ( ) > } unsafe impl Send for GPBR { } impl GPBR { # [ doc = r" Returns a pointer to the register block" ] pub fn ptr ( ) -> * const gpbr :: RegisterBlock { 0x400e_1a90 as * const _ } } impl Deref for GPBR { type Target = gpbr :: RegisterBlock ; fn deref ( & self ) -> & gpbr :: RegisterBlock { unsafe { & * GPBR :: ptr ( ) } } } # [ doc = "General Purpose Backup Registers" ] pub mod gpbr { # [ doc = r" Register block" ] # [ repr ( C ) ] pub struct RegisterBlock { # [ doc = "0x00 - General Purpose Backup Register" ] pub gpbr : [ GPBR ; 8 ] , } # [ doc = "General Purpose Backup Register" ] pub struct GPBR { register : :: vcell :: VolatileCell < u32 > } # [ doc = "General Purpose Backup Register" ] pub mod gpbr { # [ 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 :: GPBR { # [ doc = r" Modifies the contents of the register" ] # [ inline ] pub fn modify < F > ( & 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 < F > ( & self , f : F ) where F : FnOnce ( & mut W ) -> & mut W { let bits = self . register . get ( ) ; let mut w = W { bits : bits } ; 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 GPBR_VALUER { bits : u32 , } impl GPBR_VALUER { # [ doc = r" Value of the field as raw bits" ] # [ inline ] pub fn bits ( & self ) -> u32 { self . bits } } # [ doc = r" Proxy" ] pub struct _GPBR_VALUEW < 'a > { w : & 'a mut W , } impl < 'a > _GPBR_VALUEW < '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 - Value of GPBR x" ] # [ inline ] pub fn gpbr_value ( & self ) -> GPBR_VALUER { let bits = { const MASK : u32 = 0xffff_ffff ; const OFFSET : u8 = 0 ; ( ( self . bits >> OFFSET ) & MASK as u32 ) as u32 } ; GPBR_VALUER { bits } } } impl W { # [ doc = "Bits 0:31 - Value of GPBR x" ] # [ inline ] pub fn gpbr_value ( & mut self ) -> _GPBR_VALUEW { _GPBR_VALUEW { w : self } } } } } # [ no_mangle ] static mut DEVICE_PERIPHERALS : bool = false ; # [ doc = r" All the peripherals" ] # [ allow ( non_snake_case ) ] pub struct Peripherals { # [ doc = "HSMCI" ] pub HSMCI : HSMCI , # [ doc = "SSC" ] pub SSC : SSC , # [ doc = "SPI0" ] pub SPI0 : SPI0 , # [ doc = "TC0" ] pub TC0 : TC0 , # [ doc = "TC1" ] pub TC1 : TC1 , # [ doc = "TC2" ] pub TC2 : TC2 , # [ doc = "TWI0" ] pub TWI0 : TWI0 , # [ doc = "TWI1" ] pub TWI1 : TWI1 , # [ doc = "PWM" ] pub PWM : PWM , # [ doc = "USART0" ] pub USART0 : USART0 , # [ doc = "USART1" ] pub USART1 : USART1 , # [ doc = "USART2" ] pub USART2 : USART2 , # [ doc = "USART3" ] pub USART3 : USART3 , # [ doc = "UOTGHS" ] pub UOTGHS : UOTGHS , # [ doc = "EMAC" ] pub EMAC : EMAC , # [ doc = "CAN0" ] pub CAN0 : CAN0 , # [ doc = "CAN1" ] pub CAN1 : CAN1 , # [ doc = "TRNG" ] pub TRNG : TRNG , # [ doc = "ADC" ] pub ADC : ADC , # [ doc = "DMAC" ] pub DMAC : DMAC , # [ doc = "DACC" ] pub DACC : DACC , # [ doc = "SMC" ] pub SMC : SMC , # [ doc = "MATRIX" ] pub MATRIX : MATRIX , # [ doc = "PMC" ] pub PMC : PMC , # [ doc = "UART" ] pub UART : UART , # [ doc = "CHIPID" ] pub CHIPID : CHIPID , # [ doc = "EFC0" ] pub EFC0 : EFC0 , # [ doc = "EFC1" ] pub EFC1 : EFC1 , # [ doc = "PIOA" ] pub PIOA : PIOA , # [ doc = "PIOB" ] pub PIOB : PIOB , # [ doc = "PIOC" ] pub PIOC : PIOC , # [ doc = "PIOD" ] pub PIOD : PIOD , # [ doc = "RSTC" ] pub RSTC : RSTC , # [ doc = "SUPC" ] pub SUPC : SUPC , # [ doc = "RTT" ] pub RTT : RTT , # [ doc = "WDT" ] pub WDT : WDT , # [ doc = "RTC" ] pub RTC : RTC , # [ doc = "GPBR" ] pub GPBR : GPBR , } impl Peripherals { # [ doc = r" Returns all the peripherals *once*" ] # [ inline ] pub fn take ( ) -> Option < Self > { cortex_m :: interrupt :: free ( | _ | { if unsafe { DEVICE_PERIPHERALS } { None } else { Some ( unsafe { Peripherals :: steal ( ) } ) } } ) } # [ doc = r" Unchecked version of `Peripherals::take`" ] pub unsafe fn steal ( ) -> Self { debug_assert ! ( ! DEVICE_PERIPHERALS ) ; DEVICE_PERIPHERALS = true ; Peripherals { HSMCI : HSMCI { _marker : PhantomData } , SSC : SSC { _marker : PhantomData } , SPI0 : SPI0 { _marker : PhantomData } , TC0 : TC0 { _marker : PhantomData } , TC1 : TC1 { _marker : PhantomData } , TC2 : TC2 { _marker : PhantomData } , TWI0 : TWI0 { _marker : PhantomData } , TWI1 : TWI1 { _marker : PhantomData } , PWM : PWM { _marker : PhantomData } , USART0 : USART0 { _marker : PhantomData } , USART1 : USART1 { _marker : PhantomData } , USART2 : USART2 { _marker : PhantomData } , USART3 : USART3 { _marker : PhantomData } , UOTGHS : UOTGHS { _marker : PhantomData } , EMAC : EMAC { _marker : PhantomData } , CAN0 : CAN0 { _marker : PhantomData } , CAN1 : CAN1 { _marker : PhantomData } , TRNG : TRNG { _marker : PhantomData } , ADC : ADC { _marker : PhantomData } , DMAC : DMAC { _marker : PhantomData } , DACC : DACC { _marker : PhantomData } , SMC : SMC { _marker : PhantomData } , MATRIX : MATRIX { _marker : PhantomData } , PMC : PMC { _marker : PhantomData } , UART : UART { _marker : PhantomData } , CHIPID : CHIPID { _marker : PhantomData } , EFC0 : EFC0 { _marker : PhantomData } , EFC1 : EFC1 { _marker : PhantomData } , PIOA : PIOA { _marker : PhantomData } , PIOB : PIOB { _marker : PhantomData } , PIOC : PIOC { _marker : PhantomData } , PIOD : PIOD { _marker : PhantomData } , RSTC : RSTC { _marker : PhantomData } , SUPC : SUPC { _marker : PhantomData } , RTT : RTT { _marker : PhantomData } , WDT : WDT { _marker : PhantomData } , RTC : RTC { _marker : PhantomData } , GPBR : GPBR { _marker : PhantomData } , } } }